I recently saw a question looking for templates for a Product Manager portfolio. I have been a product manager for about 10 years and don't really have one of these, so here is how I interpreted the question: This is a newish product manager getting her first or next job as a PM, and was asked for a portfolio or somehow feels like she needs one to showcase her skills.
1. Expertise in our product – this is especially important if you are working on a technology product.
2. Customer domain expertise – understanding the life of the customer, and what problems she is trying to solve.
I usually expect that I can only get two out of the three areas from someone that I hire, and have to train for the third. For example (my industry is software), I might hire someone from an internal tech support or field engineering position. That person probably knows a lot about our product and customer needs, but not much about being a PM. Or, I might hire an experienced PM from another company, so they have PM skills and probably some experience with my customers, but don't know my product.
1. Product skills vary by industry, but even if someone doesn't know my product, I hope they have the fundamental technical skills for my industry, and can learn the important details of my product quickly, and connect it to other concepts in the industry.
3. PM skills & practices can (like anything else) get very advanced, but there are some basics I hope even someone new can bring. Examples are writing, analytical sills, math, basic business, people skills, visual communication skills, etc.
To build a portfolio, think about where you have skills in each area, and find or create some artifact that helps demonstrate one ore more skills. A blog can show writing, communication, analytical, and logical reasoning skills. You might also be able to show some industry knowledge, depending on your subject area. If you can point to a webpage you helped design, or write, or promote, or whatever, that is good. If there are products in the market that you worked on, point to any of the marketing material (although be clear about your contribution, so people don't assume you created the ad if you didn't).
In my last job interview, I was asked for a writing sample, and I pointed to my blog (not frequently updated, but there are some good examples of my writing & thinking), the website for my current product (I didn't build the web page, but developed the message & the product), and a couple of other websites that were hobby projects that I thought showed some important skills.
I am a huge fan of Jobs to be Done theory (JTBD). It has really revolutionized my thinking about why customers buy a product, and what makes a product great. The founding principle of the theory is that customers don't buy your product because they want your product, but because they have a job to do, and they think your product will help them. In thinking about the job that the customer is trying to do, the theory breaks them down into groups: Functional Jobs, Social Jobs, and Emotional Jobs.
The Functional Jobs are relatively easy – e.g. I need a cheaper way to get to work, or I would like to be able to check my email without carrying / starting up my computer. For functional jobs, we pretty quickly get to the kinds of performance metrics we are used to thinking about with products – the cheaper way to get to work might be satisfied by a car with better gas mileage, and checking my email might be satisfied by a smart phone or tablet. But what about the other two, Emotional and Social Jobs?
Christensen makes a point in his book to say that if the JTBD only has Functional components, then a person (or a computer) can quickly weigh the relative benefits, and there will be one obvious winner. All successful products will be forced to optimize to those dimensions, and you end up with a commodity. He wasn't suggesting that there is no room for choice or variation in your product, instead he was highlighting the importance of thinking about the other two components present in most jobs. I think a lot of us, especially if we come from an engineering background, tend to ignore and misunderstand these fuzzier-seeming components of a customer JTBD. This is especially difficult when we try to understand the difference between an emotional job and a social job.
As I try to apply JTBD theory in my work, and teach it to the people on my team, this lack of clarity shows up pretty fast. My first advice to the team was "be aware that these factors are important, look for evidence of them in our customers, and capture them in our descriptions whenever we can". In other words, take a swing at it, but we really don't understand how to examine, much less compete in these areas. We could possibly be blind to two-thirds of the problem our customers are trying to solve!
So now I am collecting examples that I think help highlight social and emotional jobs, and the difference between them. Today, I was looking at Apple iMacs, and something along this line caught my eye. Look at this photo comparing a regular 27″ iMac with the iMac Pro.
There is a huge difference in price between the two computers, and the iMac Pro offers much a much more powerful range of CPUs, bigger storage, and (not shown in the picture) more memory and better GPUs. From a functional perspective, we can see the difference between the two computers. One is much more expensive, and much more powerful. I can decide if I need the extra capability, and whether it is worth the extra price.
Now notice the colors of the two computers. The iMac Pro is Space Gray, and comes with a matching Space Gray keyboard, mouse or trackpad. Why? It doesn't have anything to do with the performance of the computer so it doesn't solve a functional job for me (like enabling me to do advanced AI modeling). What about an emotional job? Maybe I just like the way it looks, so when I sit at my desk, I enjoy the aesthetic environment more? That makes sense, and we see that the laptops are offered in multiple colors to satisfy that emotional job. But why isn't the regular iMac offered in multiple colors, so I can satisfy that job with either version?
I think Apple has limited the Space Gray to the iMac Pro to satisfy a social JTBD. When you spend that much more for a computer, you are probably doing it for a reason – you work on more advanced problems than most other people, or you can afford to buy the top of the line no matter the cost, or you are smart enough to know how to take advantage of the extra performance, or maybe the boss values you more than your colleagues. I work from my home office, so no one will know if my computer is Silver or Space Gray and there is not much social benefit to me of having that distinctive color. But imagine that I am a programmer or researcher or designer or video editor, and across all the adjacent cubicles and offices, there is a sea of 27″ silver computers. If mine is one of only a few Space Gray ones, it stands out as something different, something special, and by association, separates me as different and special.
A college professor once told me about an insurance company where all the employees had identical office furniture, right down to round trash baskets. Managers got square trash baskets. In this ocean of uniformity, the small differences were glaringly obvious. The professor said that if someone suddenly ended up with a square trash basket, other employees noticed and asked about when they had been promoted, and if they hadn't been, accused them of some sort of social fakery for having a status symbol to which they were not entitled.
I don't think Apple expects many people to buy the much more expensive Pro computer just to show off (although it seems inevitable that a few will be sold for this reason). I do think they made the Pro stand out visually as an extra benefit for these high-end customers. They are different / special / more valuable in what they do, and therefor what computer they choose (and how much they spend), and Apple wants to help them signal this to their social group.
When we are designing our own products, we should notice if the job our customer is doing when using our products is something that would elevate our customer's social status, and look for ways to help them signal that to their social group.


Watch as the ATL crew get deliciously bound in "Birthday."
Nothing makes a Monday brighter than some All Time Low! And today's a double whammy now that the band have dropped a colorful clip for new single "Birthday" following the tune's acoustic tour video. Watch ATL get festively bound below!
"We made a tasty video for our newest song, #Birthday," the band tweeted on Monday, debuting the PTracy-directed fever dream of a video. One thing's for sure: we've never been so enticed by a flamingo-topped, triple-layer birthday cake.
And, um, is that a panda at the end? You can catch All Time Low on tour now with Dashboard Confessional as part of the Summer Ever After Tour. Will there be cake onstage? See the remaining cities and dates down after the new music video.


text:
Billingshurst residents' front doors being kicked as part of "knock and run" games
Six road closures in Mid Sussex that drivers need to know about this week
Drivers in and around Mid Sussex will have six National Highways road closures to watch out for this week.
By Lawrence Smith
Tuesday, 4th January 2022, 12:13 pm
By Joseph Hook, data reporter
But the news isn't too bad, with all of them only expected to cause slight delays, of under 10 minutes.
The latest expected works list, with notes from National Highways, shows that one closure already in place is expected to carry on this week:
Mid Sussex motorists will have six road closures to watch out for this week.
A23, from 8pm November 28, 2021, to 9pm January 30, 2022, slight delays (under 10 minutes): A23 southbound, Hickstead, lane closure for off network works on behalf of West Sussex County Council.
And a further five closures will begin over the next seven days:
A23, from 8pm January 4 to 6am January 22, slight delays (under 10 minutes): A23 north and southbound, between Patcham and Peas Pottage, mobile lane closures for gully clearance.
A23, from 8pm January 4 to 6am January 5, slight delays (under 10 minutes): A23 northbound, Warninglid to Handcross, Lane closure for emergency barrier repair.
A23, from 8pm January 5 to 5am January 6, slight delays (under 10 minutes): A23 southbound, Handcross to Hickstead, Lane closure for road joint repair.
A23, from 8pm January 6 to 5am January 7, slight delays (under 10 minutes): A23 northbound, Handcross to Pease Pottage, Lane closure for drainage works.
A23, from 8pm January 14 to 6am January 17, slight delays (under 10 minutes): A23 southbound and northbound, Hickstead to Bolney Interchange, diversion route for off network works on behalf of West Sussex County Council.
National Highways is responsible for maintaining motorways and major A-roads, so closures of smaller roads will not be included in their schedule.
DriversMid SussexWest Sussex County CouncilA23Hickstead

redpajama_set_name: RedPajamaCommonCrawl


text:
IPL TRENDING
IPL mega auction for 2022 season set to take place in February first week: Reports
The decision comes after the deadline for the draft picks of the two new franchises has been extended.
(Picture Credit: BCCI/IPL)
With T20 cricket lovers all in anticipation for the next edition of the Indian Premier League (IPL) which will be played with ten teams, the forthcoming mega auctions have garnered a lot of interest among fans. This is because it is at this auction that the core of the team for the coming cycle will be decided and now it is being learned that the IPL Governing Council (IPL GC) has decided to conduct the mega auction in the first week of February.
The decision comes after the deadline for the draft picks of the two new franchises has been extended. As per a media report, IPL GC has already conveyed its decision to the franchises but the lack of clarity regarding the new Ahmedabad franchise owner CVC Sports' association in the IPL has forced the board to delay the auctions. It has also been confirmed in the report that the auction will be a two-day affair much like the previous editions of the mega auction.
The report carried by Cricket.com also claims that the mega auction might either be held in Bangalore or Hyderabad since the screening process is comparatively better in any of these two cities.
Full list of players retained by franchises ahead of IPL 2022 auction:
Chennai Super Kings (CSK): Ravindra Jadeja (16 crore), MS Dhoni (12 crore), Moeen Ali (8 crore), Ruturaj Gaikwad (6 crore)
Kolkata Knight Riders (KKR): Andre Russell (12 crore, 16 crore to be deducted from purse), Varun Chakravarthy (8 crore, 12 crore to be deducted from purse), Venkatesh Iyer (8 crore), Sunil Narine (6 crore)
Sunrisers Hyderabad (SRH): Kane Williamson (14 crore), Abdul Samad (4 crore), Umran Malik (4 crore)
Mumbai Indians (MI): Rohit Sharma (16 crore), Jasprit Bumrah (12 crore), Suryakumar Yadav(8 crore), Kieron Pollard (6 crore)
Royal Challengers Bangalore (RCB): Virat Kohli (15 crore), Glenn Maxwell (11 crore), Mohammed Siraj (7 crore)
Delhi Capitals (DC): Rishabh Pant (16 crore), Axar Patel (9 crore, 12 crore to be deducted from purse), Prithvi Shaw (7.5 crore, 8 crore to be deducted from purse), Anrich Nortje (6.5 crore)
Rajasthan Royals (RR): Sanju Samson (14 crore), Jos Buttler (10 crore), Yashasvi Jaiswal (4 crore)
Punjab Kings (PBKS): Mayank Agarwal (12 crore, 14 crore to be deducted from purse), Arshdeep Singh (4 crore)
IPL 2022 Auctions
Former IPL player and Ranji player claims he was approached with bribery offer for fixing matches
IPL 2022: Shreyas Iyer on radar of multiple franchises for captaincy as Mega Auctions near
Kolkata Knight Riders appoint Bharat Arun as bowling coach for IPL 2022
Team Lucknow looking to sign Ravi Bishnoi and Marcus Stoinis for IPL 2022: Reports


text:
Know about actress Katrina Kaif
Katrina kaif bridal look Katrina kaif cool Katrina kaif barbie Katrina kaif bride Namaste India! Watching "sheila ki jawani" on 'tees maar khan', what a rare phenomenon. the song is truly one of the best choreographed and the film is adversely screen played. what a historical bogus movie. but what I'm, about to say here is not about "sheila ki jawani" or teest maar khan but it's about our beloved extremely beautiful, charming and sizzling hot Katrina kaif. what a lady. awesome!!!! one of her real-life dialogue I say I remember is that. she told that "if i started caring about all the criticism I may fell ill, so I don't care for all the criticisms." absolutely correct! we are not here to bother every criticism but to do our task and cherish our dreams. when she had told this, she was a struggling actress in Bollywood. now see the difference she is now on the top chart. ka
Indian web products
Namaste India! a very good season to you, in the midst of playing farm Ville on facebook, I thought why I'm playing this game on facebook, which belongs to Mark Zuckerberg. why not any Indian social website? where if every Indian net user starts playing it would have 100 million users in a year. and that can make India richer by multi-multi millions. why I'm paying Zuckerberg if I can pay to reliance industries through my contributions. which made me decide to search for Indian farm Ville and I got ibibo.com. going more detailed study on websites I found we have many many more Indian websites which are far better and lucrative and user-friendly. then why a foreign website? think?????? similarly the case goes with the browsers too, we have Indian epic browser which is much superior to internet explorer or Rockmelt kind of browsers available. why not an Indian browser created by Alok Bhardwaj in hidden reflex. I remember our father of the natio
irfan pathan is the need of indian cricket team
cheteshwar pujara irfan pathan ishant sharma wasim jaffer munaf patel rohit sharma whatever the selector says, ruling out Irfan pathan for Ishant sharma don't seem sensible. irfan pathan is an all rounder and talking of his batting, he is far more better than murli vijay and rohit sharma. if you take the bowling stats he again outruns many bowlers of present indian cricket team bowlers. Ishant Sharma instead of Irfan pathan or laxman pujara type guys should not be compared with Irfan pathan. cricket now seems just the game of money and power, players are not much required by the selectors. taking wasim jaffer as the batsman he can challenge many of our present indian cricket team. but what these guys like Munaf patel,Irfan pathan or Wasim jaffer don't have is the money and power and not the talent and skill for cricket. selectors now don't want the skill or talent they need a strong and powerful back who can save their money if they happen to lose money. why a national pl
India 3rd largest population in terms of users on internet
internet google india internet in india google celebration google plate With 73.9 million users on internet India has become the third largest country in terms of internet users surpassing Japan. India is now at third spot behind China and US. Interestingly it is just the 10.1% share of the population of India. India is also the second fastest country with the growing number of internet users, which is topped by Brazil. Top 10 websites majorly visited by Indians according to Alexa are: Google.com Google.co.in Facebook.com Youtube.com Yahoo.com Blogspot.in Wikipedia.org LinkedIn.com Indiatimes.com Flipkart.com According to the Internet Watchdog ComScore India has added around 17.6 million users in the year 2012 and with this reached 73.9 million users in total, leading to the third spot in terms internet population in the world.
love story vanisha and prateek
this story starts with the first day of college. vanisha was on her way to the auditorium for attending the orientation arranged for freshers. she was too nervous and was skipping the eye contacts from any seniors those were rubbling all round the streets of her way. this behavior of vanisha pulling her head down and moving fast enough as much she can grabbed by some of her seniors and they call her for intro. she with hesitation at last thought to go there and stand in front of them. vanisha is a beautiful girl with a good height of 5'5'' and fair complexion with blessed figure "masha allah". seniors were asking her name,place and branch and streams she joined etc. to which reluctantly trying to give answers mostly by nodding her head. all this activities of vanisha and seniors were also keenly noticed by a brilliant guy prateek who was that time busy in taking his breakfast at the canteen stairs. vanisha anyhow by making some uneasy gestures succeed to escape th
zindagi nahi milti dubara
jee le yaara, yeh zindagi nahi milti dubara sath chalo, milke chalo, par chalte raho apne khwabon ko sahejo, milke badho khulke badho dekho duniya ki, samjho duniya ki, karo duniya ki faasle hain, kat bhi jayehnge, chal ke to dekho manjilein hain, raahein bhi hain, paa bhi loge daudke to dekho khule aasaman ke niche tum bhi ho hum bhi hain dharti humari bhi hai, tumhari bhi hai bas jee ke to dekho ranjish kisse nahi milti, ghum kisse nahi milte yarron unhe peeke to dekho khwaab hain, adhure hain,soch hain adhure hain koshish to karo dil se to karo paana kya hai yeh jaan ke to dekho haalaat hain, mushkilein hain, kathinaiyan hain, sabhi sabke liye hain, tum bhi unhe kholkar to dekho aasan to kuchh bhi nahi, to mushkil bhi kam hain karke to dekho himmat hai, taakat hai, roshni hai, ujale karke to dekho do char kadam apne kabhi badhake to dekho zindagi hai mauje hain jee ke to dekho zindagi ke har pal mein hans ke to dekho!
Bhubaneswar the city of Temples
Swosti Premium Bhubaneswar Bhubaneswar the capital city of the Indian state of Orissa. Its the largest city of Orissa after old capital Cuttack, once the capital of ancient Kalinga, the city has a long history of 3000 years and is today a centre of economic and religious importance. Historically Bhubaneswar has been known by different names such as Toshali, Kalinga Nagari, Nagar Kalinga, Ekamra Kanan, Ekamra Kshetra and Mandira Malinya Nagari. The modern city of Bhubaneswar was designed by the German architect Otto Königsberger in 1946. It became the political capital of the state of Odisha in 1948, a year after India gained its independence from Britain. Before Bhubaneswar, Cuttack was the capital of Odisha until 1947. Bhubaneswar and Cuttack are together known as the "twin cities" of Odisha. As per a comprehensive development plan prepared by IIT Kharagpur, the metropolitan area formed by the twin cities has a 2008 population of 1.9 million. The World gazetteer has
Auto Wale - Hindi Poem
Mere shahar ke auto wale mere nagar ke auto wale bade nirale inke khyalein kabhi kamai kabhi udaai din bhar khub auto chalate raat ko chain ki nind lete mere shahar ke auto wale! Mere nagar ke auto wale.!! kabhi do rapay ke liye ladte kabhi yunhi hans ke saste mein maan jaate dil bada aur soch bhi badi logon ki seva yahi sahi khud bhi milte logon ko bhi milate yeh mere shahar ke auto wale! mere nagar ke auto wale!!
Know about Alok Bhardwaj founder of epic browser from hidden reflex
epic browser Epic Browser is said to be the first-ever web browser from India. You must be very well aware of popular web browsers like Internet Explorer, Mozilla Firefox, Netscape Navigator, Opera and etc. But this Epic browser comes with the Indian touch and style is one of its kind. One of the reasons why Indians would like this Indian browser is its facility of typing in Indian languages. This browser is founded by a Bangalore based company called Hidden Reflex, headed by Alok Bhardwaj. epic browser logo Alok Bhardwaj, formerly a mergers & acquisitions investment banker for technology and other companies, is the founder of Hidden Reflex. Mr Bhardwaj earned a degree in philosophy from Princeton University in 1996. He is a founding member of PodVoters.org and is also the proprietor of a New York City-based educational services firm. On the launch day by hidden reflex: " We're thrilled to announce on July 15, 2010 the launch of our very first product: the
Saswat Satpathy Orissa wonder boy
Saswat Satpathy Saswat Satapathy (13), Orissa origin boy clinched a silver medal at the 19th World Memory Championship (WMC) held at Guangzhou, China, from December 2 to 6. Saswat was the top performer among Indian kids. India fared impressively by clinching the fourth spot at the championship, winning a record 64 medals. Saswat, a Class VIII student of Delhi Public School, Patna, bagged a silver medal in the names and faces category, a bronze medal in the spoken number category and also ranked fourth in abstract images category, all in the kid's section of the championship. "I am thrilled, I am now aiming to bag the Grandmaster title in the next WMC. The preparations will have to be much tougher as bagging the title is no joke. Maybe, I shall have to remember the 1000-digit number." The Indian contingent was congratulated by the Indian counsel general in Guangzhou, Indra Mani Pandey, over dinner at his residence. "I am overwhelmed at the appreciation. I shall work ha
Most beautiful mousoleum in the world Taj Mahal
Taj Mahal Taj Mahal is the finest example of Mughal architecture, a style that combines elements from Persian, Islamic and Indian architectural styles. In 1983, the Taj Mahal became a UNESCO World Heritage Site. While the white domed marble mausoleum is the most familiar component of the Taj Mahal, it is actually an integrated complex of structures. In 1631 the emperor Shah Jahan built the Taj Mahal in memory of his wife Mumtaz. The construction of the Taj Mahal was entrusted to a board of architects under imperial supervision, including Abd ul-Karim Ma'mur Khan, Makramat Khan, and Ustad Ahmad Lahauri. Lahauri is generally considered to be the principal designer. Taj Mahal was constructed over a period of twenty-two years, employing twenty thousand workers. It was completed in 1648 C.E. at a cost of 32 Million Rupees. The construction documents show that its master architect was Ustad 'Isa, the renowned Islamic architect of his time. The documents contain names o
Chandrasekhar Panda and Saswat Swain developed affordable Data Card and Laptops
chandrasekhar panda and saswat swain These two graduates +Chandrasekhar Panda and +Saswat Swain of techno school have developed a 3G technology based data card that can provide high speed internet connectivity using any mobile phone GSM network at a very low cost. The data card IWE-BLEAF can also be used as a storage device, provide access to over 150 TV channels and also a wifi hotspot providing internet access to 300 laptops and 30 cell phones at a time. they have been working on this project since the last three months. they say:"we thought of having one gadget which can give access to multiple technology in one device at an affordable price." Saswat Swain explains it as, "one has to insert a sim card of any mobile network in the 3G data card which is a pen-drive like device, then use it in personal computer or laptop to access internet facility." cost of the device would be just Rs. 1300/- and it will provide a speed of 7.2 MBPS. They have applied f
Know about CEO of Google and Alphabet Sundar Pichai
Sundar Pichai heads Google's Chrome Browser Sundar Pichai new CEO of Google's Alphabet and heads chrome OS Sundar Pichai (born 1967), a technology whiz-kid and an IITian, responsible for the development of the Google browser Chrome as the company's vice president of product development. Sundar was earlier given the role to head Android OS along with the Chrome Browser. Android was earlier headed by Andy Rubin, but due to his sudden resignation, Google asked Sundar to head both Chrome and Android. This step of Google seems to be another leap towards the emerging Android desktop soon. He is an Indian American computer engineer. Sundar Pichai prior to being appointed the CEO of Google and later CEO and President of Parent alphabet was the vice president of product management at Google Inc. Sundar Pichai received a B.Tech from the Indian Institute of Technology Kharagpur and was awarded an Institute Silver Medal. He holds an M.S. from Stanford University and an M
Know about Dr Debashis Sahoo - Stem cell researcher
Debashish Sahoo Debashis Sahoo , founding Director of 'Boolean Lab', Assistant Professor at UC San Diego and a scientist who has expertise in developing computational approaches. Dr Sahoo worked on identifying simple Boolean relationships between gene expression values. Dr Sahoo analyze large publicly available biological datasets to identify strong Boolean rules in a particular domain such as one tissue, one species or across species between mammals. These rules are called Boolean invariant if all the data collected in that domain follow the same Boolean formula. His research helps in finding new genes that play a role in developing cancer. He is researching on developing new methods to analyze high-throughput biological datasets. he has developed several tools and techniques to analyze large collections of microarray datasets. he has made specific biological predictions and then validated them in collaborations with several biologists at Stanford. The tools through w
Know about creator of world's first implantable artificial kidney - Shuvu Roy
Artificial Implantable Kidney Shuvu Roy A US-based Indian origin researcher Shuvu Roy has created the world's first implantable artificial kidney. what is sensational about Roy's creation is that the organ, not larger than the size of a coffee cup, will be able to mimic the kidney's most vital functions like filtering toxins out of the bloodstream, regulate the blood pressure and produce the all-important vitamins like vitamin D. the artificial kidney has been tested successfully on animals and its human trials are expected to be held over the next five years. once available and if affordable, this creation of Roy led the team at the University of California will do away with the need for kidney dialysis. this will be a boon for the patients suffering from chronic kidney disease (CKD). in india, of about 1.5 lac patients of CKD, only 3500 are able to get kidney transplanted and 6000-10,000 opt for dialysis. the rest perish thanks to the acute shortage of dia
Know about Wipro head and philanthropist Azim Premji
Wipro Head Azim Premji Timeline of Azim Premji 2019 - Forbes Asia names Azim Premji Asia's most generous philanthropist. 2005 - Government of India honoured Azim Premji with Padma Bhushan 2003 - Azim Premji was among the 50 richest people in the world listed by Forbes 2001 - Azim Premji was among the 50 richest people in the world listed by Forbes 2000 - Asiaweek magazine voted Premji among the 20 most powerful men in the world Azim Hashim Premji is born 24 July 1945 is an Indian business tycoon, philanthropist and the chairman of Wipro Limited, a group company that holds Wipro Technologies, India's third-largest software development companies. According to Forbes, he is currently the second richest Indian with a personal wealth of US$17 billion in 2010. In 2000, he was voted among the 20 most powerful men in the world by Asiaweek. He was also among the 50 richest people in the world from 2001 to 2003 according to Forbes. In April 2004, he was rated among th
Goa tourist hub of india
Goa beach images Update: Goa has been positioned sixth in the list of top 10 nightlife cities in the world by 'National Geographic'. Goa is regarded as one of the safest tourism destination in the world. According to National Geographic's ' Top 10 Nightlife Cities ' list, Dublin in Ireland ranked first, followed by Belgrade in Serbia, La Paz in Bolivia, Sao Paulo in Brazil, San Juan in Puerto Rico, Goa In India, Ibiza in Spain, Houston in Texas, Thessaloniki in Greece and Baku in Azerbaijan. I n News: International travel magazine Conde Nast has chosen Goa as the best leisure destination in the country overtaking Kerala. This year 2013, Feast of St Francis Xavier will be celebrated at the Basilica of Bom Jesus , Old Goa on December 3. India's smallest state by area and the fourth smallest by population. Located in South West India in the region known as the Konkan, it is bounded by the state of Maharashtra to the north, and by Karnataka to the
India 3rd largest population in terms of users on ...
Know about Alok Bhardwaj founder of epic browser f...
Chandrasekhar Panda and Saswat Swain developed aff...
Know about creator of world's first implantable ar...


Bedford's Central Library was the venue for this year's CLIS Annual Lecture: a fascinating two-hander by Tony Collins, Publishing Director for Monarch Books and Lion Fiction, and Penelope Wilcock, established author of poetry and fiction, including The Hawk and the Dove series. Their theme was Christian fiction, seen from both the publisher's and the author's point of view.
Tony kicked off with a run-down on Christian fiction production in the UK, which is surprisingly different from Christian fiction production in the United States. This is because much Christian fiction comes from the pens of evangelicals, who are the Christian mainstream in the US, but who feel far more marginalised in the UK, and this is reflected not only in the publication of Christian fiction, but in the writing of it too.
Fiction in general is overwhelmingly popular – people like a good story, and they are prepared to suspend their prejudices when reading or hearing one. So a persuasive argument wrapped in a good story is likely to be better received than the reasoned argument alone. There are still dangers however in trying to put forward an argument forcefully; Tony instanced two very popular modern secular writers, some of whose later novels he feels descend into unappealing (anti-Christian) propaganda.
What makes fiction Christian? Firstly, it should be written by a Christian, and secondly, it should have a thread of redemption running through it, affirming the best things in life: goodness, truth, forgiveness, a spirit of service. When Tony considers publishing a novel, he is looking for writing that promotes these qualities, but without an overtly Christian agenda.
Penelope spoke about the process of writing Christian fiction; she felt that it can't help putting out a message – all stories do. She agreed with Tony that humans are moved by stories, as they wouldn't be by doctrine. And stories have the added advantage of being able to present a debate without having to present a logical ending. Dogmatism has no place in Christian fiction (rambling monologues being a particular turn-off).
Key to a good novel is authenticity, with the author getting inside a character or a situation, and the reader finishing the novel feeling moved to compassion.


Sato Y, Nagasaki M, Kubota M, Kiramura I, Tokudome M, Kajioka T, Shinomiya Y, and Ozawa T.
Passive exercise training improves insulin sensitivity in elder diabetic patients.
Shinomiya Y, Wang S, Ishida K, and Kimura T.
Development and muscle strength training evaluation for horseback riding therapeutic equipment.
J Robotics and Mechatoronics 14: 597-630, 2002.


text:
Pope Francis arrives in UAE for historic visit to Arabian Peninsula
By Cristina Abellan Matamoros & Reuters •et; last updated: 03/02/2019
Pope Francis arrived in the United Arab Emirates on Sunday for a historic visit to the Arabian Peninsula.
The Pope will spend less than 48 hours in the UAE, where he will meet Muslim leaders in an effort to promote interfaith dialogue.
He has described the visit as an opportunity to write "a new page in the history of relations between religions".
He will also celebrate an outdoor mass for some for some 135,000 Catholics, an unprecedented event in the Arabian peninsula.
About two million expatriate Catholics live in the Arabian peninsula, many of them migrant workers. About half of them live in the UAE who said the visit reflects its history as a "cradle of diversity".
Peace Gathering in Abu Dhabi
Before leaving for Abu Dhabi, Francis said he was following the humanitarian crisis in Yemen with great concern and urged all sides to implement a peace deal and deliver aid to millions suffering from famine in the war-torn country during his regular Sunday mass in Vatican City.
"I appeal to all sides involved and to the international community to urgently press for respect of the agreements that have been reached, guarantee the distribution of food, and work for the good of the population," he told the crowd. "I invite everybody to pray strongly for our brothers in Yemen."
UAE's Foreign Minister Anwar Gargash said on Twitter they welcomed the Pope's message on Yemen and believes the peace deal he referred to was a historic breakthrough.
"Let us assure its implementation and make 2019 the year of peace in Yemen," he said.
The UAE plays an important role in the Saudi-led coalition against the Iran-aligned Houthi movement that controls the Yemeni capital. In December, the warring parties agreed on a ceasefire at the first major peace talks of the nearly four-year-old war.
The UN is trying to implement a truce and troop withdrawal deal in the Yemeni port of Hodeidah, which could be a step towards the end of the conflict.
It's not clear whether Pope Francis will raise the subject during his visit.
Francis was greeted by Abu Dhabi's Crown Prince Sheikh Mohammed bin Zayed al-Nahyan, who escorted him to meet Sheikh Ahmed al-Tayeb, the Grand Imam of Egypt's Al-Azhar mosque and university, a main seat of Sunni Islam education.
Pope Francis, Head of the Catholic Church shakes hands with Sheikh Ahmed Mohamed el-Tayeb, Egyptian Imam of al-Azhar Mosque, upon his arrival at Abu Dhabi International airport in Abu Dhabi, United Arab Emirates, February 3, 2019.WAM/Handout via REUTERS
US Secretary of State Department, Mike Pompeo, welcomed the pope's historic visit to the region.
Nearly half of French and Germans think Islam clashes with their values: Survey
Pope bombarded with insults after tweeting to pray for migrants
Vladimir Putin meets Giuseppe Conte and Pope Francis in Rome


text:
package com.sun.tools.javac.processing;

import java.io.Closeable;
import java.io.File;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.*;
import java.util.regex.*;

import javax.annotation.processing.*;
import javax.lang.model.SourceVersion;
import javax.lang.model.element.*;
import javax.lang.model.util.*;
import javax.tools.DiagnosticListener;
import javax.tools.JavaFileManager;
import javax.tools.JavaFileObject;
import javax.tools.StandardJavaFileManager;
import static javax.tools.StandardLocation.*;

import com.sun.source.util.JavacTask;
import com.sun.source.util.TaskEvent;
import com.sun.tools.javac.api.BasicJavacTask;
import com.sun.tools.javac.api.JavacTrees;
import com.sun.tools.javac.api.MultiTaskListener;
import com.sun.tools.javac.code.*;
import com.sun.tools.javac.code.Symbol.*;
import com.sun.tools.javac.file.FSInfo;
import com.sun.tools.javac.file.JavacFileManager;
import com.sun.tools.javac.jvm.*;
import com.sun.tools.javac.jvm.ClassReader.BadClassFile;
import com.sun.tools.javac.main.JavaCompiler;
import com.sun.tools.javac.model.JavacElements;
import com.sun.tools.javac.model.JavacTypes;
import com.sun.tools.javac.parser.*;
import com.sun.tools.javac.tree.*;
import com.sun.tools.javac.tree.JCTree.*;
import com.sun.tools.javac.util.Abort;
import com.sun.tools.javac.util.Assert;
import com.sun.tools.javac.util.ClientCodeException;
import com.sun.tools.javac.util.Context;
import com.sun.tools.javac.util.Convert;
import com.sun.tools.javac.util.JCDiagnostic;
import com.sun.tools.javac.util.JavacMessages;
import com.sun.tools.javac.util.List;
import com.sun.tools.javac.util.Log;
import com.sun.tools.javac.util.Name;
import com.sun.tools.javac.util.Names;
import com.sun.tools.javac.util.Options;
import com.sun.tools.javac.util.ServiceLoader;
import static com.sun.tools.javac.code.Lint.LintCategory.PROCESSING;
import static com.sun.tools.javac.main.Option.*;
import static com.sun.tools.javac.comp.CompileStates.CompileState;
import static com.sun.tools.javac.util.JCDiagnostic.DiagnosticFlag.*;

/**
 * Objects of this class hold and manage the state needed to support
 * annotation processing.
 *
 *
This is NOT part of any supported API.
 * If you write code that depends on this, you do so at your own risk.
 * This code and its internal interfaces are subject to change or
 * deletion without notice.
 */
public class JavacProcessingEnvironment implements ProcessingEnvironment, Closeable {
    private final Options options;

    private final boolean printProcessorInfo;
    private final boolean printRounds;
    private final boolean verbose;
    private final boolean lint;
    private final boolean fatalErrors;
    private final boolean werror;
    private final boolean showResolveErrors;

    private final JavacFiler filer;
    private final JavacMessager messager;
    private final JavacElements elementUtils;
    private final JavacTypes typeUtils;

    /**
     * Holds relevant state history of which processors have been
     * used.
     */
    private DiscoveredProcessors discoveredProcs;

    /**
     * Map of processor-specific options.
     */
    private final Map<String, String> processorOptions;

    /**
     */
    private final Set<String> unmatchedProcessorOptions;

    /**
     * Annotations implicitly processed and claimed by javac.
     */
    private final Set<String> platformAnnotations;

    /**
     * Set of packages given on command line.
     */
    private Set<PackageSymbol> specifiedPackages = Collections.emptySet();

    /** The log to be used for error reporting.
     */
    Log log;

    /** Diagnostic factory.
     */
    JCDiagnostic.Factory diags;

    /**
     * Source level of the compile.
     */
    Source source;

    private ClassLoader processorClassLoader;
    private SecurityException processorClassLoaderException;

    /**
     * JavacMessages object used for localization
     */
    private JavacMessages messages;

    private MultiTaskListener taskListener;

    private Context context;

    /** Get the JavacProcessingEnvironment instance for this context. */
    public static JavacProcessingEnvironment instance(Context context) {
        JavacProcessingEnvironment instance = context.get(JavacProcessingEnvironment.class);
        if (instance == null)
            instance = new JavacProcessingEnvironment(context);
        return instance;
    }

    protected JavacProcessingEnvironment(Context context) {
        this.context = context;
        context.put(JavacProcessingEnvironment.class, this);
        log = Log.instance(context);
        source = Source.instance(context);
        diags = JCDiagnostic.Factory.instance(context);
        options = Options.instance(context);
        printProcessorInfo = options.isSet(XPRINTPROCESSORINFO);
        printRounds = options.isSet(XPRINTROUNDS);
        verbose = options.isSet(VERBOSE);
        lint = Lint.instance(context).isEnabled(PROCESSING);
        if (options.isSet(PROC, "only") || options.isSet(XPRINT)) {
            JavaCompiler compiler = JavaCompiler.instance(context);
            compiler.shouldStopPolicyIfNoError = CompileState.PROCESS;
        }
        fatalErrors = options.isSet("fatalEnterError");
        showResolveErrors = options.isSet("showResolveErrors");
        werror = options.isSet(WERROR);
        platformAnnotations = initPlatformAnnotations();

        // Initialize services before any processors are initialized
        // in case processors use them.
        filer = new JavacFiler(context);
        messager = new JavacMessager(context, this);
        elementUtils = JavacElements.instance(context);
        typeUtils = JavacTypes.instance(context);
        processorOptions = initProcessorOptions(context);
        unmatchedProcessorOptions = initUnmatchedProcessorOptions();
        messages = JavacMessages.instance(context);
        taskListener = MultiTaskListener.instance(context);
        initProcessorClassLoader();
    }

    public void setProcessors(Iterable<? extends Processor> processors) {
        Assert.checkNull(discoveredProcs);
        initProcessorIterator(context, processors);
    }

    private Set<String> initPlatformAnnotations() {
        Set<String> platformAnnotations = new HashSet<String>();
        platformAnnotations.add("java.lang.Deprecated");
        platformAnnotations.add("java.lang.Override");
        platformAnnotations.add("java.lang.SuppressWarnings");
        platformAnnotations.add("java.lang.annotation.Documented");
        platformAnnotations.add("java.lang.annotation.Inherited");
        platformAnnotations.add("java.lang.annotation.Retention");
        platformAnnotations.add("java.lang.annotation.Target");
        return Collections.unmodifiableSet(platformAnnotations);
    }

    private void initProcessorClassLoader() {
        JavaFileManager fileManager = context.get(JavaFileManager.class);
        try {
            // If processorpath is not explicitly set, use the classpath.
            processorClassLoader = fileManager.hasLocation(ANNOTATION_PROCESSOR_PATH)
                ? fileManager.getClassLoader(ANNOTATION_PROCESSOR_PATH)
                : fileManager.getClassLoader(CLASS_PATH);

            if (processorClassLoader != null && processorClassLoader instanceof Closeable) {
                JavaCompiler compiler = JavaCompiler.instance(context);
                compiler.closeables = compiler.closeables.prepend((Closeable) processorClassLoader);
            }
        } catch (SecurityException e) {
            processorClassLoaderException = e;
        }
    }

    private void initProcessorIterator(Context context, Iterable<? extends Processor> processors) {
        Log   log   = Log.instance(context);
        Iterator<? extends Processor> processorIterator;

        if (options.isSet(XPRINT)) {
            try {
                Processor processor = PrintingProcessor.class.newInstance();
                processorIterator = List.of(processor).iterator();
            } catch (Throwable t) {
                AssertionError assertError =
                    new AssertionError("Problem instantiating PrintingProcessor.");
                assertError.initCause(t);
                throw assertError;
            }
        } else if (processors != null) {
            processorIterator = processors.iterator();
        } else {
            String processorNames = options.get(PROCESSOR);
            if (processorClassLoaderException == null) {
                /*
                 * If the "-processor" option is used, search the appropriate
                 * path for the named class.  Otherwise, use a service
                 * provider mechanism to create the processor iterator.
                 */
                if (processorNames != null) {
                    processorIterator = new NameProcessIterator(processorNames, processorClassLoader, log);
                } else {
                    processorIterator = new ServiceIterator(processorClassLoader, log);
                }
            } else {
                /*
                 * A security exception will occur if we can't create a classloader.
                 * Ignore the exception if, with hindsight, we didn't need it anyway
                 * (i.e. no processor was specified either explicitly, or implicitly,
                 * in service configuration file.) Otherwise, we cannot continue.
                 */
                processorIterator = handleServiceLoaderUnavailability("proc.cant.create.loader",
                        processorClassLoaderException);
            }
        }
        discoveredProcs = new DiscoveredProcessors(processorIterator);
    }

    /**
     * Returns an empty processor iterator if no processors are on the
     * relevant path, otherwise if processors are present, logs an
     * error.  Called when a service loader is unavailable for some
     * reason, either because a service loader class cannot be found
     * or because a security policy prevents class loaders from being
     * created.
     *
     * @param key The resource key to use to log an error message
     * @param e   If non-null, pass this exception to Abort
     */
    private Iterator<Processor> handleServiceLoaderUnavailability(String key, Exception e) {
        JavaFileManager fileManager = context.get(JavaFileManager.class);

        if (fileManager instanceof JavacFileManager) {
            StandardJavaFileManager standardFileManager = (JavacFileManager) fileManager;
            Iterable<? extends File> workingPath = fileManager.hasLocation(ANNOTATION_PROCESSOR_PATH)
                ? standardFileManager.getLocation(ANNOTATION_PROCESSOR_PATH)
                : standardFileManager.getLocation(CLASS_PATH);

            if (needClassLoader(options.get(PROCESSOR), workingPath) )
                handleException(key, e);

        } else {
            handleException(key, e);
        }

        java.util.List<Processor> pl = Collections.emptyList();
        return pl.iterator();
    }

    /**
     * Handle a security exception thrown during initializing the
     * Processor iterator.
     */
    private void handleException(String key, Exception e) {
        if (e != null) {
            log.error(key, e.getLocalizedMessage());
            throw new Abort(e);
        } else {
            log.error(key);
            throw new Abort();
        }
    }

    /**
     * Use a service loader appropriate for the platform to provide an
     * iterator over annotations processors; fails if a loader is
     * needed but unavailable.
     */
    private class ServiceIterator implements Iterator<Processor> {
        private Iterator<Processor> iterator;
        private Log log;
        private ServiceLoader<Processor> loader;

        ServiceIterator(ClassLoader classLoader, Log log) {
            this.log = log;
            try {
                try {
                    loader = ServiceLoader.load(Processor.class, classLoader);
                    this.iterator = loader.iterator();
                } catch (Exception e) {
                    // Fail softly if a loader is not actually needed.
                    this.iterator = handleServiceLoaderUnavailability("proc.no.service", null);
                }
            } catch (Throwable t) {
                log.error("proc.service.problem");
                throw new Abort(t);
            }
        }

        public boolean hasNext() {
            try {
                return iterator.hasNext();
            } catch(ServiceConfigurationError sce) {
                log.error("proc.bad.config.file", sce.getLocalizedMessage());
                throw new Abort(sce);
            } catch (Throwable t) {
                throw new Abort(t);
            }
        }

        public Processor next() {
            try {
                return iterator.next();
            } catch (ServiceConfigurationError sce) {
                log.error("proc.bad.config.file", sce.getLocalizedMessage());
                throw new Abort(sce);
            } catch (Throwable t) {
                throw new Abort(t);
            }
        }

        public void remove() {
            throw new UnsupportedOperationException();
        }

        public void close() {
            if (loader != null) {
                try {
                    loader.reload();
                } catch(Exception e) {
                    ; // Ignore problems during a call to reload.
                }
            }
        }
    }

    private static class NameProcessIterator implements Iterator<Processor> {
        Processor nextProc = null;
        Iterator<String> names;
        ClassLoader processorCL;
        Log log;

        NameProcessIterator(String names, ClassLoader processorCL, Log log) {
            this.names = Arrays.asList(names.split(",")).iterator();
            this.processorCL = processorCL;
            this.log = log;
        }

        public boolean hasNext() {
            if (nextProc != null)
                return true;
            else {
                if (!names.hasNext())
                    return false;
                else {
                    String processorName = names.next();

                    Processor processor;
                    try {
                        try {
                            processor =
                                (Processor) (processorCL.loadClass(processorName).newInstance());
                        } catch (ClassNotFoundException cnfe) {
                            log.error("proc.processor.not.found", processorName);
                            return false;
                        } catch (ClassCastException cce) {
                            log.error("proc.processor.wrong.type", processorName);
                            return false;
                        } catch (Exception e ) {
                            log.error("proc.processor.cant.instantiate", processorName);
                            return false;
                        }
                    } catch(ClientCodeException e) {
                        throw e;
                    } catch(Throwable t) {
                        throw new AnnotationProcessingError(t);
                    }
                    nextProc = processor;
                    return true;
                }

            }
        }

        public Processor next() {
            if (hasNext()) {
                Processor p = nextProc;
                nextProc = null;
                return p;
            } else
                throw new NoSuchElementException();
        }

        public void remove () {
            throw new UnsupportedOperationException();
        }
    }

    public boolean atLeastOneProcessor() {
        return discoveredProcs.iterator().hasNext();
    }

    private Map<String, String> initProcessorOptions(Context context) {
        Options options = Options.instance(context);
        Set<String> keySet = options.keySet();
        Map<String, String> tempOptions = new LinkedHashMap<String, String>();

        for(String key : keySet) {
            if (key.startsWith("-A") && key.length() > 2) {
                int sepIndex = key.indexOf('=');
                String candidateKey = null;
                String candidateValue = null;

                if (sepIndex == -1)
                    candidateKey = key.substring(2);
                else if (sepIndex >= 3) {
                    candidateKey = key.substring(2, sepIndex);
                    candidateValue = (sepIndex < key.length()-1)?
                        key.substring(sepIndex+1) : null;
                }
                tempOptions.put(candidateKey, candidateValue);
            }
        }

        return Collections.unmodifiableMap(tempOptions);
    }

    private Set<String> initUnmatchedProcessorOptions() {
        Set<String> unmatchedProcessorOptions = new HashSet<String>();
        unmatchedProcessorOptions.addAll(processorOptions.keySet());
        return unmatchedProcessorOptions;
    }

    /**
     * State about how a processor has been used by the tool.  If a
     * processor has been used on a prior round, its process method is
     * called on all subsequent rounds, perhaps with an empty set of
     * annotations to process.  The {@code annotationSupported} method
     * caches the supported annotation information from the first (and
     * only) getSupportedAnnotationTypes call to the processor.
     */
    static class ProcessorState {
        public Processor processor;
        public boolean   contributed;
        private ArrayList<Pattern> supportedAnnotationPatterns;
        private ArrayList<String>  supportedOptionNames;

        ProcessorState(Processor p, Log log, Source source, ProcessingEnvironment env) {
            processor = p;
            contributed = false;

            try {
                processor.init(env);

                checkSourceVersionCompatibility(source, log);

                supportedAnnotationPatterns = new ArrayList<Pattern>();
                for (String importString : processor.getSupportedAnnotationTypes()) {
                    supportedAnnotationPatterns.add(importStringToPattern(importString,
                                                                          processor,
                                                                          log));
                }

                supportedOptionNames = new ArrayList<String>();
                for (String optionName : processor.getSupportedOptions() ) {
                    if (checkOptionName(optionName, log))
                        supportedOptionNames.add(optionName);
                }

            } catch (ClientCodeException e) {
                throw e;
            } catch (Throwable t) {
                throw new AnnotationProcessingError(t);
            }
        }

        /**
         * Checks whether or not a processor's source version is
         * compatible with the compilation source version.  The
         * processor's source version needs to be greater than or
         * equal to the source version of the compile.
         */
        private void checkSourceVersionCompatibility(Source source, Log log) {
            SourceVersion procSourceVersion = processor.getSupportedSourceVersion();

            if (procSourceVersion.compareTo(Source.toSourceVersion(source)) < 0 )  {
                log.warning("proc.processor.incompatible.source.version",
                            procSourceVersion,
                            processor.getClass().getName(),
                            source.name);
            }
        }

        private boolean checkOptionName(String optionName, Log log) {
            boolean valid = isValidOptionName(optionName);
            if (!valid)
                log.error("proc.processor.bad.option.name",
                            optionName,
                            processor.getClass().getName());
            return valid;
        }

        public boolean annotationSupported(String annotationName) {
            for(Pattern p: supportedAnnotationPatterns) {
                if (p.matcher(annotationName).matches())
                    return true;
            }
            return false;
        }

        /**
         * Remove options that are matched by this processor.
         */
        public void removeSupportedOptions(Set<String> unmatchedProcessorOptions) {
            unmatchedProcessorOptions.removeAll(supportedOptionNames);
        }
    }

    // TODO: These two classes can probably be rewritten better...
    /**
     * This class holds information about the processors that have
     * been discoverd so far as well as the means to discover more, if
     * necessary.  A single iterator should be used per round of
     * annotation processing.  The iterator first visits already
     * discovered processors then fails over to the service provider
     * mechanism if additional queries are made.
     */
    class DiscoveredProcessors implements Iterable<ProcessorState> {

        class ProcessorStateIterator implements Iterator<ProcessorState> {
            DiscoveredProcessors psi;
            Iterator<ProcessorState> innerIter;
            boolean onProcInterator;

            ProcessorStateIterator(DiscoveredProcessors psi) {
                this.psi = psi;
                this.innerIter = psi.procStateList.iterator();
                this.onProcInterator = false;
            }

            public ProcessorState next() {
                if (!onProcInterator) {
                    if (innerIter.hasNext())
                        return innerIter.next();
                    else
                        onProcInterator = true;
                }

                if (psi.processorIterator.hasNext()) {
                    ProcessorState ps = new ProcessorState(psi.processorIterator.next(),
                                                           log, source, JavacProcessingEnvironment.this);
                    psi.procStateList.add(ps);
                    return ps;
                } else
                    throw new NoSuchElementException();
            }

            public boolean hasNext() {
                if (onProcInterator)
                    return  psi.processorIterator.hasNext();
                else
                    return innerIter.hasNext() || psi.processorIterator.hasNext();
            }

            public void remove () {
                throw new UnsupportedOperationException();
            }

            /**
             * Run all remaining processors on the procStateList that
             * have not already run this round with an empty set of
             * annotations.
             */
            public void runContributingProcs(RoundEnvironment re) {
                if (!onProcInterator) {
                    Set<TypeElement> emptyTypeElements = Collections.emptySet();
                    while(innerIter.hasNext()) {
                        ProcessorState ps = innerIter.next();
                        if (ps.contributed)
                            callProcessor(ps.processor, emptyTypeElements, re);
                    }
                }
            }
        }

        Iterator<? extends Processor> processorIterator;
        ArrayList<ProcessorState>  procStateList;

        public ProcessorStateIterator iterator() {
            return new ProcessorStateIterator(this);
        }

        DiscoveredProcessors(Iterator<? extends Processor> processorIterator) {
            this.processorIterator = processorIterator;
            this.procStateList = new ArrayList<ProcessorState>();
        }

        /**
         * Free jar files, etc. if using a service loader.
         */
        public void close() {
            if (processorIterator != null &&
                processorIterator instanceof ServiceIterator) {
                ((ServiceIterator) processorIterator).close();
            }
        }
    }

    private void discoverAndRunProcs(Context context,
                                     Set<TypeElement> annotationsPresent,
                                     List<ClassSymbol> topLevelClasses,
                                     List<PackageSymbol> packageInfoFiles) {
        Map<String, TypeElement> unmatchedAnnotations =
            new HashMap<String, TypeElement>(annotationsPresent.size());

        for(TypeElement a  : annotationsPresent) {
                unmatchedAnnotations.put(a.getQualifiedName().toString(),
                                         a);
        }

        // Give "*" processors a chance to match
        if (unmatchedAnnotations.size() == 0)
            unmatchedAnnotations.put("", null);

        DiscoveredProcessors.ProcessorStateIterator psi = discoveredProcs.iterator();
        // TODO: Create proper argument values; need past round
        // information to fill in this constructor.  Note that the 1
        // st round of processing could be the last round if there
        // were parse errors on the initial source files; however, we
        // are not doing processing in that case.

        Set<Element> rootElements = new LinkedHashSet<Element>();
        rootElements.addAll(topLevelClasses);
        rootElements.addAll(packageInfoFiles);
        rootElements = Collections.unmodifiableSet(rootElements);

        RoundEnvironment renv = new JavacRoundEnvironment(false,
                                                          false,
                                                          rootElements,
                                                          JavacProcessingEnvironment.this);

        while(unmatchedAnnotations.size() > 0 && psi.hasNext() ) {
            ProcessorState ps = psi.next();
            Set<String>  matchedNames = new HashSet<String>();
            Set<TypeElement> typeElements = new LinkedHashSet<TypeElement>();

            for (Map.Entry<String, TypeElement> entry: unmatchedAnnotations.entrySet()) {
                String unmatchedAnnotationName = entry.getKey();
                if (ps.annotationSupported(unmatchedAnnotationName) ) {
                    matchedNames.add(unmatchedAnnotationName);
                    TypeElement te = entry.getValue();
                    if (te != null)
                        typeElements.add(te);
                }
            }

            if (matchedNames.size() > 0 || ps.contributed) {
                boolean processingResult = callProcessor(ps.processor, typeElements, renv);
                ps.contributed = true;
                ps.removeSupportedOptions(unmatchedProcessorOptions);

                if (printProcessorInfo || verbose) {
                    log.printLines("x.print.processor.info",
                            ps.processor.getClass().getName(),
                            matchedNames.toString(),
                            processingResult);
                }

                if (processingResult) {
                    unmatchedAnnotations.keySet().removeAll(matchedNames);
                }

            }
        }
        unmatchedAnnotations.remove("");

        if (lint && unmatchedAnnotations.size() > 0) {
            // Remove annotations processed by javac
            unmatchedAnnotations.keySet().removeAll(platformAnnotations);
            if (unmatchedAnnotations.size() > 0) {
                log = Log.instance(context);
                log.warning("proc.annotations.without.processors",
                            unmatchedAnnotations.keySet());
            }
        }

        // Run contributing processors that haven't run yet
        psi.runContributingProcs(renv);

        // Debugging
        if (options.isSet("displayFilerState"))
            filer.displayState();
    }

    /**
     * Computes the set of annotations on the symbol in question.
     * Leave class public for external testing purposes.
     */
    public static class ComputeAnnotationSet extends
        ElementScanner8<Set<TypeElement>, Set<TypeElement>> {
        final Elements elements;

        public ComputeAnnotationSet(Elements elements) {
            super();
            this.elements = elements;
        }

        @Override
        public Set<TypeElement> visitPackage(PackageElement e, Set<TypeElement> p) {
            // Don't scan enclosed elements of a package
            return p;
        }

        @Override
        public Set<TypeElement> visitType(TypeElement e, Set<TypeElement> p) {
            // Type parameters are not considered to be enclosed by a type
            scan(e.getTypeParameters(), p);
            return scan(e.getEnclosedElements(), p);
        }

        @Override
        public Set<TypeElement> visitExecutable(ExecutableElement e, Set<TypeElement> p) {
            // Type parameters are not considered to be enclosed by an executable
            scan(e.getTypeParameters(), p);
            return scan(e.getEnclosedElements(), p);
        }

        void addAnnotations(Element e, Set<TypeElement> p) {
            for (AnnotationMirror annotationMirror :
                     elements.getAllAnnotationMirrors(e) ) {
                Element e2 = annotationMirror.getAnnotationType().asElement();
                p.add((TypeElement) e2);
            }
        }

        @Override
        public Set<TypeElement> scan(Element e, Set<TypeElement> p) {
            addAnnotations(e, p);
            return super.scan(e, p);
        }
    }

    private boolean callProcessor(Processor proc,
                                         Set<? extends TypeElement> tes,
                                         RoundEnvironment renv) {
        try {
            return proc.process(tes, renv);
        } catch (BadClassFile ex) {
            log.error("proc.cant.access.1", ex.sym, ex.getDetailValue());
            return false;
        } catch (CompletionFailure ex) {
            StringWriter out = new StringWriter();
            ex.printStackTrace(new PrintWriter(out));
            log.error("proc.cant.access", ex.sym, ex.getDetailValue(), out.toString());
            return false;
        } catch (ClientCodeException e) {
            throw e;
        } catch (Throwable t) {
            throw new AnnotationProcessingError(t);
        }
    }

    /**
     * Helper object for a single round of annotation processing.
     */
    class Round {
        /** The round number. */
        final int number;
        /** The context for the round. */
        final Context context;
        /** The compiler for the round. */
        final JavaCompiler compiler;
        /** The log for the round. */
        final Log log;
        /** The diagnostic handler for the round. */
        final Log.DeferredDiagnosticHandler deferredDiagnosticHandler;

        /** The ASTs to be compiled. */
        List<JCCompilationUnit> roots;
        /** The classes to be compiler that have were generated. */
        Map<String, JavaFileObject> genClassFiles;

        /** The set of annotations to be processed this round. */
        Set<TypeElement> annotationsPresent;
        /** The set of top level classes to be processed this round. */
        List<ClassSymbol> topLevelClasses;
        /** The set of package-info files to be processed this round. */
        List<PackageSymbol> packageInfoFiles;

        /** Create a round (common code). */
        private Round(Context context, int number, int priorErrors, int priorWarnings,
                Log.DeferredDiagnosticHandler deferredDiagnosticHandler) {
            this.context = context;
            this.number = number;

            compiler = JavaCompiler.instance(context);
            log = Log.instance(context);
            log.nerrors = priorErrors;
            log.nwarnings = priorWarnings;
            if (number == 1) {
                Assert.checkNonNull(deferredDiagnosticHandler);
                this.deferredDiagnosticHandler = deferredDiagnosticHandler;
            } else {
                this.deferredDiagnosticHandler = new Log.DeferredDiagnosticHandler(log);
            }

            // the following is for the benefit of JavacProcessingEnvironment.getContext()
            JavacProcessingEnvironment.this.context = context;

            // the following will be populated as needed
            topLevelClasses  = List.nil();
            packageInfoFiles = List.nil();
        }

        /** Create the first round. */
        Round(Context context, List<JCCompilationUnit> roots, List<ClassSymbol> classSymbols,
                Log.DeferredDiagnosticHandler deferredDiagnosticHandler) {
            this(context, 1, 0, 0, deferredDiagnosticHandler);
            this.roots = roots;
            genClassFiles = new HashMap<String,JavaFileObject>();

            compiler.todo.clear(); // free the compiler's resources

            // The reverse() in the following line is to maintain behavioural
            // compatibility with the previous revision of the code. Strictly speaking,
            // it should not be necessary, but a javah golden file test fails without it.
            topLevelClasses =
                getTopLevelClasses(roots).prependList(classSymbols.reverse());

            packageInfoFiles = getPackageInfoFiles(roots);

            findAnnotationsPresent();
        }

        /** Create a new round. */
        private Round(Round prev,
                Set<JavaFileObject> newSourceFiles, Map<String,JavaFileObject> newClassFiles) {
            this(prev.nextContext(),
                    prev.number+1,
                    prev.compiler.log.nerrors,
                    prev.compiler.log.nwarnings,
                    null);
            this.genClassFiles = prev.genClassFiles;

            List<JCCompilationUnit> parsedFiles = compiler.parseFiles(newSourceFiles);
            roots = cleanTrees(prev.roots).appendList(parsedFiles);

            // Check for errors after parsing
            if (unrecoverableError())
                return;

            enterClassFiles(genClassFiles);
            List<ClassSymbol> newClasses = enterClassFiles(newClassFiles);
            genClassFiles.putAll(newClassFiles);
            enterTrees(roots);

            if (unrecoverableError())
                return;

            topLevelClasses = join(
                    getTopLevelClasses(parsedFiles),
                    getTopLevelClassesFromClasses(newClasses));

            packageInfoFiles = join(
                    getPackageInfoFiles(parsedFiles),
                    getPackageInfoFilesFromClasses(newClasses));

            findAnnotationsPresent();
        }

        /** Create the next round to be used. */
        Round next(Set<JavaFileObject> newSourceFiles, Map<String, JavaFileObject> newClassFiles) {
            try {
                return new Round(this, newSourceFiles, newClassFiles);
            } finally {
                compiler.close(false);
            }
        }

        /** Create the compiler to be used for the final compilation. */
        JavaCompiler finalCompiler() {
            try {
                Context nextCtx = nextContext();
                JavacProcessingEnvironment.this.context = nextCtx;
                JavaCompiler c = JavaCompiler.instance(nextCtx);
                c.log.initRound(compiler.log);
                return c;
            } finally {
                compiler.close(false);
            }
        }

        /** Return the number of errors found so far in this round.
         * This may include uncoverable errors, such as parse errors,
         * and transient errors, such as missing symbols. */
        int errorCount() {
            return compiler.errorCount();
        }

        /** Return the number of warnings found so far in this round. */
        int warningCount() {
            return compiler.warningCount();
        }

        /** Return whether or not an unrecoverable error has occurred. */
        boolean unrecoverableError() {
            if (messager.errorRaised())
                return true;

            for (JCDiagnostic d: deferredDiagnosticHandler.getDiagnostics()) {
                switch (d.getKind()) {
                    case WARNING:
                        if (werror)
                            return true;
                        break;

                    case ERROR:
                        if (fatalErrors || !d.isFlagSet(RECOVERABLE))
                            return true;
                        break;
                }
            }

            return false;
        }

        /** Find the set of annotations present in the set of top level
         *  classes and package info files to be processed this round. */
        void findAnnotationsPresent() {
            ComputeAnnotationSet annotationComputer = new ComputeAnnotationSet(elementUtils);
            // Use annotation processing to compute the set of annotations present
            annotationsPresent = new LinkedHashSet<TypeElement>();
            for (ClassSymbol classSym : topLevelClasses)
                annotationComputer.scan(classSym, annotationsPresent);
            for (PackageSymbol pkgSym : packageInfoFiles)
                annotationComputer.scan(pkgSym, annotationsPresent);
        }

        /** Enter a set of generated class files. */
        private List<ClassSymbol> enterClassFiles(Map<String, JavaFileObject> classFiles) {
            ClassReader reader = ClassReader.instance(context);
            Names names = Names.instance(context);
            List<ClassSymbol> list = List.nil();

            for (Map.Entry<String,JavaFileObject> entry : classFiles.entrySet()) {
                Name name = names.fromString(entry.getKey());
                JavaFileObject file = entry.getValue();
                if (file.getKind() != JavaFileObject.Kind.CLASS)
                    throw new AssertionError(file);
                ClassSymbol cs;
                if (isPkgInfo(file, JavaFileObject.Kind.CLASS)) {
                    Name packageName = Convert.packagePart(name);
                    PackageSymbol p = reader.enterPackage(packageName);
                    if (p.package_info == null)
                        p.package_info = reader.enterClass(Convert.shortName(name), p);
                    cs = p.package_info;
                    if (cs.classfile == null)
                        cs.classfile = file;
                } else
                    cs = reader.enterClass(name, file);
                list = list.prepend(cs);
            }
            return list.reverse();
        }

        /** Enter a set of syntax trees. */
        private void enterTrees(List<JCCompilationUnit> roots) {
            compiler.enterTrees(roots);
        }

        /** Run a processing round. */
        void run(boolean lastRound, boolean errorStatus) {
            printRoundInfo(lastRound);

            if (!taskListener.isEmpty())
                taskListener.started(new TaskEvent(TaskEvent.Kind.ANNOTATION_PROCESSING_ROUND));

            try {
                if (lastRound) {
                    filer.setLastRound(true);
                    Set<Element> emptyRootElements = Collections.emptySet(); // immutable
                    RoundEnvironment renv = new JavacRoundEnvironment(true,
                            errorStatus,
                            emptyRootElements,
                            JavacProcessingEnvironment.this);
                    discoveredProcs.iterator().runContributingProcs(renv);
                } else {
                    discoverAndRunProcs(context, annotationsPresent, topLevelClasses, packageInfoFiles);
                }
            } catch (Throwable t) {
                // we're specifically expecting Abort here, but if any Throwable
                // comes by, we should flush all deferred diagnostics, rather than
                // drop them on the ground.
                deferredDiagnosticHandler.reportDeferredDiagnostics();
                log.popDiagnosticHandler(deferredDiagnosticHandler);
                throw t;
            } finally {
                if (!taskListener.isEmpty())
                    taskListener.finished(new TaskEvent(TaskEvent.Kind.ANNOTATION_PROCESSING_ROUND));
            }
        }

        void showDiagnostics(boolean showAll) {
            Set<JCDiagnostic.Kind> kinds = EnumSet.allOf(JCDiagnostic.Kind.class);
            if (!showAll) {
                // suppress errors, which are all presumed to be transient resolve errors
                kinds.remove(JCDiagnostic.Kind.ERROR);
            }
            deferredDiagnosticHandler.reportDeferredDiagnostics(kinds);
            log.popDiagnosticHandler(deferredDiagnosticHandler);
        }

        /** Print info about this round. */
        private void printRoundInfo(boolean lastRound) {
            if (printRounds || verbose) {
                List<ClassSymbol> tlc = lastRound ? List.<ClassSymbol>nil() : topLevelClasses;
                Set<TypeElement> ap = lastRound ? Collections.<TypeElement>emptySet() : annotationsPresent;
                log.printLines("x.print.rounds",
                        number,
                        "{" + tlc.toString(", ") + "}",
                        ap,
                        lastRound);
            }
        }

        /** Get the context for the next round of processing.
         * Important values are propagated from round to round;
         * other values are implicitly reset.
         */
        private Context nextContext() {
            Context next = new Context(context);

            Options options = Options.instance(context);
            Assert.checkNonNull(options);
            next.put(Options.optionsKey, options);

            Locale locale = context.get(Locale.class);
            if (locale != null)
                next.put(Locale.class, locale);

            Assert.checkNonNull(messages);
            next.put(JavacMessages.messagesKey, messages);

            final boolean shareNames = true;
            if (shareNames) {
                Names names = Names.instance(context);
                Assert.checkNonNull(names);
                next.put(Names.namesKey, names);
            }

            DiagnosticListener<?> dl = context.get(DiagnosticListener.class);
            if (dl != null)
                next.put(DiagnosticListener.class, dl);

            MultiTaskListener mtl = context.get(MultiTaskListener.taskListenerKey);
            if (mtl != null)
                next.put(MultiTaskListener.taskListenerKey, mtl);

            FSInfo fsInfo = context.get(FSInfo.class);
            if (fsInfo != null)
                next.put(FSInfo.class, fsInfo);

            JavaFileManager jfm = context.get(JavaFileManager.class);
            Assert.checkNonNull(jfm);
            next.put(JavaFileManager.class, jfm);
            if (jfm instanceof JavacFileManager) {
                ((JavacFileManager)jfm).setContext(next);
            }

            Names names = Names.instance(context);
            Assert.checkNonNull(names);
            next.put(Names.namesKey, names);

            Tokens tokens = Tokens.instance(context);
            Assert.checkNonNull(tokens);
            next.put(Tokens.tokensKey, tokens);

            Log nextLog = Log.instance(next);
            nextLog.initRound(log);

            JavaCompiler oldCompiler = JavaCompiler.instance(context);
            JavaCompiler nextCompiler = JavaCompiler.instance(next);
            nextCompiler.initRound(oldCompiler);

            filer.newRound(next);
            messager.newRound(next);
            elementUtils.setContext(next);
            typeUtils.setContext(next);

            JavacTask task = context.get(JavacTask.class);
            if (task != null) {
                next.put(JavacTask.class, task);
                if (task instanceof BasicJavacTask)
                    ((BasicJavacTask) task).updateContext(next);
            }

            JavacTrees trees = context.get(JavacTrees.class);
            if (trees != null) {
                next.put(JavacTrees.class, trees);
                trees.updateContext(next);
            }

            context.clear();
            return next;
        }
    }

    // TODO: internal catch clauses?; catch and rethrow an annotation
    // processing error
    public JavaCompiler doProcessing(Context context,
                                     List<JCCompilationUnit> roots,
                                     List<ClassSymbol> classSymbols,
                                     Iterable<? extends PackageSymbol> pckSymbols,
                                     Log.DeferredDiagnosticHandler deferredDiagnosticHandler) {
        log = Log.instance(context);

        Set<PackageSymbol> specifiedPackages = new LinkedHashSet<PackageSymbol>();
        for (PackageSymbol psym : pckSymbols)
            specifiedPackages.add(psym);
        this.specifiedPackages = Collections.unmodifiableSet(specifiedPackages);

        Round round = new Round(context, roots, classSymbols, deferredDiagnosticHandler);

        boolean errorStatus;
        boolean moreToDo;
        do {
            // Run processors for round n
            round.run(false, false);

            // Processors for round n have run to completion.
            // Check for errors and whether there is more work to do.
            errorStatus = round.unrecoverableError();
            moreToDo = moreToDo();

            round.showDiagnostics(errorStatus || showResolveErrors);

            // Set up next round.
            // Copy mutable collections returned from filer.
            round = round.next(
                    new LinkedHashSet<JavaFileObject>(filer.getGeneratedSourceFileObjects()),
                    new LinkedHashMap<String,JavaFileObject>(filer.getGeneratedClasses()));

             // Check for errors during setup.
            if (round.unrecoverableError())
                errorStatus = true;

        } while (moreToDo && !errorStatus);

        // run last round
        round.run(true, errorStatus);
        round.showDiagnostics(true);

        filer.warnIfUnclosedFiles();
        warnIfUnmatchedOptions();

        /*
         * If an annotation processor raises an error in a round,
         * that round runs to completion and one last round occurs.
         * The last round may also occur because no more source or
         * class files have been generated.  Therefore, if an error
         * was raised on either of the last *two* rounds, the compile
         * should exit with a nonzero exit code.  The current value of
         * errorStatus holds whether or not an error was raised on the
         * second to last round; errorRaised() gives the error status
         * of the last round.
         */
        if (messager.errorRaised()
                || werror && round.warningCount() > 0 && round.errorCount() > 0)
            errorStatus = true;

        Set<JavaFileObject> newSourceFiles =
                new LinkedHashSet<JavaFileObject>(filer.getGeneratedSourceFileObjects());
        roots = cleanTrees(round.roots);

        JavaCompiler compiler = round.finalCompiler();

        if (newSourceFiles.size() > 0)
            roots = roots.appendList(compiler.parseFiles(newSourceFiles));

        errorStatus = errorStatus || (compiler.errorCount() > 0);

        // Free resources
        this.close();

        if (!taskListener.isEmpty())
            taskListener.finished(new TaskEvent(TaskEvent.Kind.ANNOTATION_PROCESSING));

        if (errorStatus) {
            if (compiler.errorCount() == 0)
                compiler.log.nerrors++;
            return compiler;
        }

        compiler.enterTreesIfNeeded(roots);

        return compiler;
    }

    private void warnIfUnmatchedOptions() {
        if (!unmatchedProcessorOptions.isEmpty()) {
            log.warning("proc.unmatched.processor.options", unmatchedProcessorOptions.toString());
        }
    }

    /**
     * Free resources related to annotation processing.
     */
    public void close() {
        filer.close();
        if (discoveredProcs != null) // Make calling close idempotent
            discoveredProcs.close();
        discoveredProcs = null;
    }

    private List<ClassSymbol> getTopLevelClasses(List<? extends JCCompilationUnit> units) {
        List<ClassSymbol> classes = List.nil();
        for (JCCompilationUnit unit : units) {
            for (JCTree node : unit.defs) {
                if (node.hasTag(JCTree.Tag.CLASSDEF)) {
                    ClassSymbol sym = ((JCClassDecl) node).sym;
                    Assert.checkNonNull(sym);
                    classes = classes.prepend(sym);
                }
            }
        }
        return classes.reverse();
    }

    private List<ClassSymbol> getTopLevelClassesFromClasses(List<? extends ClassSymbol> syms) {
        List<ClassSymbol> classes = List.nil();
        for (ClassSymbol sym : syms) {
            if (!isPkgInfo(sym)) {
                classes = classes.prepend(sym);
            }
        }
        return classes.reverse();
    }

    private List<PackageSymbol> getPackageInfoFiles(List<? extends JCCompilationUnit> units) {
        List<PackageSymbol> packages = List.nil();
        for (JCCompilationUnit unit : units) {
            if (isPkgInfo(unit.sourcefile, JavaFileObject.Kind.SOURCE)) {
                packages = packages.prepend(unit.packge);
            }
        }
        return packages.reverse();
    }

    private List<PackageSymbol> getPackageInfoFilesFromClasses(List<? extends ClassSymbol> syms) {
        List<PackageSymbol> packages = List.nil();
        for (ClassSymbol sym : syms) {
            if (isPkgInfo(sym)) {
                packages = packages.prepend((PackageSymbol) sym.owner);
            }
        }
        return packages.reverse();
    }

    // avoid unchecked warning from use of varargs
    private static <T> List<T> join(List<T> list1, List<T> list2) {
        return list1.appendList(list2);
    }

    private boolean isPkgInfo(JavaFileObject fo, JavaFileObject.Kind kind) {
        return fo.isNameCompatible("package-info", kind);
    }

    private boolean isPkgInfo(ClassSymbol sym) {
        return isPkgInfo(sym.classfile, JavaFileObject.Kind.CLASS) && (sym.packge().package_info == sym);
    }

    /*
     * Called retroactively to determine if a class loader was required,
     * after we have failed to create one.
     */
    private boolean needClassLoader(String procNames, Iterable<? extends File> workingpath) {
        if (procNames != null)
            return true;

        URL[] urls = new URL[1];
        for(File pathElement : workingpath) {
            try {
                urls[0] = pathElement.toURI().toURL();
                if (ServiceProxy.hasService(Processor.class, urls))
                    return true;
            } catch (MalformedURLException ex) {
                throw new AssertionError(ex);
            }
            catch (ServiceProxy.ServiceConfigurationError e) {
                log.error("proc.bad.config.file", e.getLocalizedMessage());
                return true;
            }
        }

        return false;
    }

    private static <T extends JCTree> List<T> cleanTrees(List<T> nodes) {
        for (T node : nodes)
            treeCleaner.scan(node);
        return nodes;
    }

    private static final TreeScanner treeCleaner = new TreeScanner() {
            public void scan(JCTree node) {
                super.scan(node);
                if (node != null)
                    node.type = null;
            }
            public void visitTopLevel(JCCompilationUnit node) {
                node.packge = null;
                super.visitTopLevel(node);
            }
            public void visitClassDef(JCClassDecl node) {
                node.sym = null;
                super.visitClassDef(node);
            }
            public void visitMethodDef(JCMethodDecl node) {
                node.sym = null;
                super.visitMethodDef(node);
            }
            public void visitVarDef(JCVariableDecl node) {
                node.sym = null;
                super.visitVarDef(node);
            }
            public void visitNewClass(JCNewClass node) {
                node.constructor = null;
                super.visitNewClass(node);
            }
            public void visitAssignop(JCAssignOp node) {
                node.operator = null;
                super.visitAssignop(node);
            }
            public void visitUnary(JCUnary node) {
                node.operator = null;
                super.visitUnary(node);
            }
            public void visitBinary(JCBinary node) {
                node.operator = null;
                super.visitBinary(node);
            }
            public void visitSelect(JCFieldAccess node) {
                node.sym = null;
                super.visitSelect(node);
            }
            public void visitIdent(JCIdent node) {
                node.sym = null;
                super.visitIdent(node);
            }
            public void visitAnnotation(JCAnnotation node) {
                node.attribute = null;
                super.visitAnnotation(node);
            }
        };

    private boolean moreToDo() {
        return filer.newFiles();
    }

    /**
     * {@inheritdoc}
     *
     * Command line options suitable for presenting to annotation
     * processors.
     * {@literal "-Afoo=bar"} should be {@literal "-Afoo" => "bar"}.
     */
    public Map<String,String> getOptions() {
        return processorOptions;
    }

    public Messager getMessager() {
        return messager;
    }

    public Filer getFiler() {
        return filer;
    }

    public JavacElements getElementUtils() {
        return elementUtils;
    }

    public JavacTypes getTypeUtils() {
        return typeUtils;
    }

    public SourceVersion getSourceVersion() {
        return Source.toSourceVersion(source);
    }

    public Locale getLocale() {
        return messages.getCurrentLocale();
    }

    public Set<Symbol.PackageSymbol> getSpecifiedPackages() {
        return specifiedPackages;
    }

    private static final Pattern allMatches = Pattern.compile(".*");
    public static final Pattern noMatches  = Pattern.compile("(\\P{all})+");

    /**
     * Convert import-style string for supported annotations into a
     * regex matching that string.  If the string is a valid
     * import-style string, return a regex that won't match anything.
     */
    private static Pattern importStringToPattern(String s, Processor p, Log log) {
        if (isValidImportString(s)) {
            return validImportStringToPattern(s);
        } else {
            log.warning("proc.malformed.supported.string", s, p.getClass().getName());
            return noMatches; // won't match any valid identifier
        }
    }

    /**
     * Return true if the argument string is a valid import-style
     * string specifying claimed annotations; return false otherwise.
     */
    public static boolean isValidImportString(String s) {
        if (s.equals("*"))
            return true;

        boolean valid = true;
        String t = s;
        int index = t.indexOf('*');

        if (index != -1) {
            // '*' must be last character...
            if (index == t.length() -1) {
                // ... any and preceding character must be '.'
                if ( index-1 >= 0 ) {
                    valid = t.charAt(index-1) == '.';
                    // Strip off ".*$" for identifier checks
                    t = t.substring(0, t.length()-2);
                }
            } else
                return false;
        }

        // Verify string is off the form (javaId \.)+ or javaId
        if (valid) {
            String[] javaIds = t.split("\\.", t.length()+2);
            for(String javaId: javaIds)
                valid &= SourceVersion.isIdentifier(javaId);
        }
        return valid;
    }

    public static Pattern validImportStringToPattern(String s) {
        if (s.equals("*")) {
            return allMatches;
        } else {
            String s_prime = s.replace(".", "\\.");

            if (s_prime.endsWith("*")) {
                s_prime =  s_prime.substring(0, s_prime.length() - 1) + ".+";
            }

            return Pattern.compile(s_prime);
        }
    }

    /**
     * For internal use only.  This method may be removed without warning.
     */
    public Context getContext() {
        return context;
    }

    /**
     * For internal use only.  This method may be removed without warning.
     */
    public ClassLoader getProcessorClassLoader() {
        return processorClassLoader;
    }

    public String toString() {
        return "javac ProcessingEnvironment";
    }

    public static boolean isValidOptionName(String optionName) {
        for(String s : optionName.split("\\.", -1)) {
            if (!SourceVersion.isIdentifier(s))
                return false;
        }
        return true;
    }
}

redpajama_set_name: RedPajamaGithub


As every company in the world becomes a software company, the importance of collaborative design software extends to every company and many more team members than ever before. Design is no longer just designers—it's product, engineering, marketing, UX research and management—all working together to build a unique user experience.
Figma has created the first browser-based interface design tool, making it significantly easier for teams to design software together. Figma's cloud-based platform connects to other tools, scripts and web apps, making the design process more streamlined and collaborative. With Figma's approach, multiple designers can work on a project simultaneously and bring new products to market faster.


13. Don't take 10 years to get your four-year degree.
Word to the wise: Unless you want to be a doctor, lawyer or nuclear physicist, get your degree in four years – even if your major is Home Economics. One of my roommates chose that as her major and ended up being a real-estate appraiser making upward of $175,000 per year (well, the market was good once).
I'm still in college going for two BAs and on track to finish those both in 4 years, which will be completed by June 2013. The majors are Asian Literature & Culture: Chinese and Art (studio). The reason I choose them is because I have interest in those two things and nobody encouraged me to change my course of action. I have 2 quarters go, but still have no idea what the heck I'm going to do when I get out.
Now, although most people expect to get out and start working, I know that's not going to happen for me. Not only am I 21 going on 22, but I don't even know how to drive. Which means I couldn't do any internships or off campus jobs for experience in fields to find out what I may or may not want to do in the future. So my suggestion is this: regardless of what you're doing in college, please find ways to get experience learning out what you do or don't want to do with your BA.
Took me seven. Just to be a graphic designer/art director. Though to be fair, none of my peers were able to complete their degrees in less than five or six. I started in fine arts and swerved over to visual communication, which was a minor detour. And an impacted program with a portfolio review tacked on another year or two. Still, I wouldn't change it for the world. Totally worth it to do something you love. Plus, I had time to take all kinds of interesting electives. My mom always said, "knowledge and education are never a waste of time." I agree!
Well, I wish I'd had your experience. I'm very glad to have my four-year degree, but boy, some of the detours I took – like two years of business classes – I could have done without. I don't think I'll ever appreciate Accounting I and II or Business Law…But yes, all totally worth it!