I get asked occasionally about the self-publishing process and how it compares to the “professional” publishing process, since I have done both. I thought it might be interesting to compare and contrast these two approaches. The professional approach is regimented, organized, and carries many advantages, while self-publishing allows total freedom, at the cost of doing a lot more work for a lot less money.
During the promotion of my first book, I wrote a post about the experience of working with a professional publisher:
I know that working with John [editor of my book] and the Prags [Pragmatic Programmers, the publishers] has made me a better writer, but would I be confident enough to “go it alone”? Given my lack of notability, I feel I benefit greatly from having my work published and distributed by the Prags. Further, knowing my writing style and abilities as I do, my work will be much higher quality with a team of professionals in my corner.
The post is very “pro professional”, and I had a great experience. I also sold (and continue to sell) a good number of copies. As of now, I’ve sold over 6,000 copies of Build Awesome Command Line Apps With Ruby. I’m happy with those results, especially considering what a niche topic it is.
I conclude with
That being said, I’d still love to try self-publishing at some point…
With my current book, I got my chance. I proposed it to the Pragmatic Programmers, however they didn’t feel it was a good fit for them. The topic of the book is broad—what every programmer needs to know besides coding—and they have at least three titles that could overlap with the subject matter.
I wanted the book to be written, so I soldiered on alone, deciding to self-publish. I have not sold nearly as many copies as I had with my first book at this point, but I’m still happy with the results, and certainly not done promoting the new book.
Having gone through both a professional publishing and a self-publishing process, I thought it might be interesting to shed some light on how these two processes work. These are only two data points, so your mileage may vary.
Working with Professionals
My original post contains a good deal of information about what it’s like to work with a team of publishing professionals. Obviously, it’s only one datapoint, but my experience jibes with most other tech authors I’ve talked to. The basic process is:
- Proposal accepted
- Development editor assigned
- Write a chapter
- Editor reviews
- Revise chapter based on feedback
- Repeat from step 4 until chapter is good
- Repeat from step 3 until about 25% done
- Managing editor review
- Revise as needed, then back to step 3 until half done
- Publisher review
- Revise as needed, then back to step 3 until mostly done
- Tech reviews (these might happen earlier)
- Copy-editing, indexing, and typesetting
- Release!
Let’s delve a bit deeper into some of these, because they are relevant to the self-publishing process.
The day-to-day writing and revising is done by me, the author, with the help of a development editor. The development editor isn’t concerned with commas, spelling, or grammar. Instead, they’re charged with ensuring that the quality of the writing is high. They will focus on flow, consistency and general “interestingness”. The development editor is the only person you can be sure will read your book in great detail, which is a handy person to have around.
So, if the development editor isn’t worried about commas and grammar, who does? The answer is the copy-editor. God bless these people, because it sounds like an awful job. They comb through the manuscript fixing all of the typos the author has made. This is done at the end because a) typos and missing commas aren’t important to the creative process and b) the text is likely to change during development, so there’s no sense in copy-editing more than once.
Similarly, indexing and typesetting are saved until the end as well. Indexing is what it sounds like—making the index. Typesetting is a bit more involved.
In the old school, the author might produce the book in Word or some other electronic format designed for editing and commentary (or perhaps even a typed/written manuscript in the real old school). Once the work is done, the text is transferred to a system like Quark or FrameMaker to be set for printing. Many publishers still work this way. The Pragmatic Programmers, however, pioneered a better way. They have a toolchain whereby you write your book in text that can be converted into a beautifully typeset PDF (as well as various e-reader formats). They even have a build server set up to build your book whenever you commit changes.
Despite the automation, there is still some manual tweaking that must happen before the book can be printed, and so there is a final stage of manually adjusting the typography to ensure words are hyphenated in the correct place, there are no words on pages by themselves, etc.
The real power of this system is that they can typeset the book for more than just print. While the PDF looks like the printed book, readers also get an ePUB and a MOBI for reading on a wide variety of e-readers. I don’t know how much manual tweaking they do to this part, but given my experience with these formats (below), they’ve created some powerful tools that produce really great e-reader formats.
If this sounds like a lot of process, it is! It’s all focused on producing the best book you can, in terms of both content and presentation. Since the publisher is fronting the money to pay the staff and produce the book before any copies are sold, they rightly want regular check-ins that progress is being made and that the quality is sufficient. In other words, this process makes a lot of sense to me.
Let’s talk about what’s good and what’s bad with this process.
The Good
Getting eyes on your book as you write is awesome. There’s no doubt in my mind that my book was markedly better for having worked with this team of professionals. Getting feedback from the publisher was also something that can’t be underestimated. Their feedback was borderline brutal, but it came from the right place and was what I needed to hear to do my best work.
In terms of presentation, the end product looks beautiful on paper, and looks great on all the various electronic reading formats that permeate today’s technical landscape. I never once had to worry about formatting, fonts, the Kindle DX, or anything.
They also have the setup to get your book into stores, listed on Amazon, etc. As we’ll see later, this is no small feat and while most of my sales were from the Pragmatic Programmers website, I still sold over 1400 copies from “somewhere else”.
Finally, the publisher is a known entity that people look to for technical books. The same book listed on their website vs only on an author’s website is going to sell far more, simply because it becomes known to many more people. Having a book published by a real publisher is a form of promotion that can be hard to match. And it’s the detailed process I’ve just described that creates that reputation for quality.
The Bad
Firstly, all of this costs money, so my royalty per copy is roughly 50% of what the publisher collects from buyers. Although we are in the “The Bad” section, let me be clear that a 50% royalty is far above average. No other publisher that I know of is paying this high a rate. To be honest, 50% seems way too generous, given what’s provided for me and the support I get. But, as great as their royalty rate is, it’s still a cost—the wonderful staff and tools don’t come free, and this is the price.
Secondly, all the check-ins and reviews are forms of gate-keeping. Editor approvals, copy-editing, indexing, and typesetting are gate-keeping activities, meaning that my ability to work on, promote, and sell the book is dependent on others. In effect, I need permission to work on the book. I learned very quickly that working on Chapter 4 while Chapter 3 was still being reviewed and revised was a Very Bad Idea™. Changes in one affect the other, and so while my work is being reviewed, there isn’t a whole lot I can do while I’m waiting. Remember, the vast majority of the time spent creating a book is in revising and editing, not “getting it down”.
Intellectually, I know that these gatekeepers are there for a reason, and that we are all on the same team, and that this process is designed to produce great results. And it does do that, however it can still be frustrating. Particularly because I do this in my free time, which has to be carefully managed and budgeted. If I have time to write, but feel unable to do so, it feels like a waste. It also made the entire process feel slow. Even if it really needed to take that long, the feeling of slowness can be de-motivating.
A more serious downside to the gate-keeping is that these gatekeepers must share your vision, or be convinced of it. I agreed wholeheartedly with the vast majority of feedback I got from the editors and publisher, however there were times were I felt their advice was just wrong. Not “wrong” as in “how to sell books” or “how English works”, but “that is not what I want to say”. And so you have to convince someone to let you say what you want, or you have to compromise. It never once got adversarial, but it was frustrating to have to convince someone that my vision was correct. I can only imagine how painful this is for books that aren’t as objective as technology books.
The final downside is that not anyone can engage with a publisher. They only take on so many books at once, and so you have to propose a book and convince them to help you develop it. It is this process that ensures the publisher’s reputation for quality books, and provides the “instant promotion” you get by publishing with them.
As I mentioned, the proposal for my current book was turned down, so I decided to do all of this myself.
Going it Alone
Given the process I outlined when working with a publisher, you might be thinking that self-publishing is completely freeing and reduces the process to:
- Write Book
- Put on Website
Nope. Turns out it’s more work.
Although the gate-keeping aspects of the professional process are frustrating at times, the process itself is a good one. Even though I wouldn’t have a team helping me, I still wanted to produce a book of comparable quality. That means I had to play the role of development editor, managing editor, publisher, copy-editor and typesetter all on my own.
At this point, I had a first draft done, so I decided on this process:
- Cobble a toolchain together to validate I could generate the needed formats.
- Revise and edit a chapter.
- Sleep on edits and revise again.
- Repeat step 3 as necessary.
- Repeat step 2 until done with all chapters.
- Re-read book, looking for flow and consistency. Revise as needed.
- Sleep on edits and repeat step 6 as needed.
- Get a tech review from trusted friends and colleagues.
- Revise, then go to step 6 as needed.
- Set up needed accounts for distribution and payment processing.
- Design cover for printed book.
- Design website for book.
- Copy-edit
- Finish off toolchain.
- Done!
The role of development editor was played by me after a night’s sleep, along with removing the words “this”, “very”, and “thing” from my dictionary (so they would show up as mis-spelled and I could eliminate them for better words). The role of copy-editor was played by a Ruby script. I had it look for common mistakes that I personally make and don’t catch while reading. It turns out, I use a lot of commas. We’ll get to the typesetting in a moment.
The hope was that by replicating the process in a disciplined fashion, I could produce something of quality without needing the other individuals to be involved (and, therefore, paid). For the creative aspects of the book, this is hard to gage. I feel like the writing in my book is pretty good, but there’s no way to know how much better it could be, or what affect that would have on sales.
Other than actually getting the book written, I needed to handle typesetting it, distributing it, and getting paid for it.
Distribution and Payment Processing
I created a spreadsheet of about six different ways I could distribute the eBook and collect payments. I actually did this before I got too far into the writing, because LeanPub was one of my options, and they provide a tool-chain along with distribution and payments. Not surprisingly, they were by far the most expensive, costing 10% of the sale price plus 50 cents per copy sold1. Still, way cheaper than professional publishing, but for going on your own (and being willing to deal with the toolchain yourself—no small task as we’ll see), any other way is going to be cheaper.
I looked at Square Space, Shopify, Fetch App, Digital Delivery (now called Send Owl), and DPD. They were all comparable in price, charging small monthly fees for distribution, with the payment processor (in most cases, Stripe), charging around 3% of the sale. I went with Send Owl as they had the cheapest monthly rate, a good variety of coupon and discounting options, and the nicest looking default UI for the buying experience. Setting up accounts with Send Owl and Stripe was incredibly simple, and the integration worked flawlessly.
If only the toolchain would’ve been that easy.
Toolchain
The toolchain takes the source material—your writing—and produces electronic formats for distribution. The three most common are PDF, ePub, and MOBI. There are various tools that can help and they are all pretty terrible, especially when you care as much about the typography of the end-result as I do. I wanted the PDF version to look professionally typeset. The output of a word processor is not what I wanted, and the PDFs generated by asciidoc and pandoc look horrendous to me.
That meant LaTeX. The Pragmatic Programmers toolchain appeared to me to be based on LaTeX, and I had experience with it during grad school, so I knew I could use it to get the desired output. LaTeX is not for the faint-of-heart and while its output is nothing short of beautiful, it is not a tool designed around ease of use.
LaTeX also doesn’t have a good way to produce e-reader formats from LaTeX source, and it is not enjoyable to write or edit in LaTeX’s arcane markup language. I wrote the rough draft in Markdown, however Markdown doesn’t support cross references, which I knew I would need, so I went with Asciidoc.
I then set up a basic toolchain like so:
- Asciidoc fed into pandoc
- pandoc generated LaTeX and ePub
- LaTeX generated PDF
- Calibre generated the MOBI from the ePub
I spent quite a bit of time customizing the PDF output, but I think it was worth it. I used the memoir LaTeX package, which makes it significantly easier to set margins, font sizes, headers, and footers, so that I could create a look that was unique, and that would also fit the page size I planned to use for the print version. It came out great, although was incredibly painful and time-consuming to get right. The world of TeX and LaTeX is not well-traveled, and so documentation is hard to come by.
Other than Memoir and LaTeX, I ended up being incredibly disappointed with every other element of the toolchain. pandoc stripped out all the cross-references and any other feature that its internal representation didn’t support (I added them back via some very hacky Ruby scripts). pandoc’s epub was bare-bones and underwhelming, despite the power of the format (at least on iPad). Calibre’s Kindle output was downright awful.
MOBI is fairly terrible and inflexible, and Calibre generated a pretty awful-looking book. If you look at any bullet-list in my book on a real Kindle, you’ll see what I mean. It looks terrible. And I didn’t realize it until I was completely done and had no energy left to figure it out.
If I do this again, I will write my own ePub and MOBI generator, possibly by using Docbook or HTML as the source and generating LaTeX, ePub, and MOBI from that, using all the power those formats offer. LeanPub’s toolchain looks decent, but the typography of the PDFs is not very good, in my opinion. It’s better than a word processor export, but still not amazing.
When I was mostly done with the book, I discovered Tablo, which is a cloud-based toolchain aimed at getting your book into Amazon and the iBookstore. I do not like writing in degenerate web-based editors without version control, and they provide no PDF option that I can see, so I would not use this service. They are a better option than exporting from a word processor, though.
To make a longer story short, this is a rathole. Do not underestimate the amount of effort required to produce a nicely typeset book. But please, do not produce a poorly typeset book. They are a chore to read.
The Print Version
I knew I wanted to do a print run, so once I had the PDF output how I liked it, I ordered a copy from LuLu, the only print-on-demand service provider I could find. One copy is $7, and it arrived in a few days. It looks and feels like a real book. The cover and paper are quite nice, and because of the typesetting, it looks great. The color on the cover is a bit more variable than I would like, but for the price and convenience of not having to order in bulk, this works really well.
Integrating them into my store was not so easy.
The Buying Experience
Send Owl is very straightforward: you upload whatever you are selling, set a price, and they give you a URL. You configure payment methods and you are off to the races.
They also have the concept of a “package” where you can sell multiple items at once for a total reduced cost. Once I had the print stuff ready to go, I wanted to create a package that gets you the ebook and the print book for a collective discount. This is where I ran into trouble. Send Owl doesn’t do fulfillment. To get LuLu to fulfill, readers would need to buy from them direct, but LuLu provides no discount code mechanism, so I couldn’t offer the book, fulfilled from LuLu, at a reduced price to eBook buyers.
I also couldn’t do it the other way around, because LuLu will not provide you with the email addresses of buyers (or any way to contact them), so there was no way to get buyers of the physical book a discount code on the ebook!
So, I ordered 20 copies at cost and decided to fulfill them myself. Of course, Send Owl has no way to calculate shipping, so I had to set a price that included shipping, but still appeared to be a good deal. To date, I’ve made $135 on the package deal, and spent $35 on shipping. Not good.
Interestingly, once I started offering the package, it required buyers to make a choice: do they get the ebook or the package? It turns out that many of them decide to get neither. The extra step of requiring a decision hurt conversion, so I killed the package. Now, readers who buy the ebook get an email to buy direct form LuLu, at a reduced price. That link is good for anyone, so anyone with the link can get the book for that price, making it not really that “reduced”. And now I have 17 books sitting in my closet.
That covers direct sales, but what about other channels?
Other Sales Channels
Early on, I looked at Kindle Direct Publishing (KDP). This seemed like a pretty easy way to get listed on Amazon, and at least be a place where reviews could be written and found. Unfortunately, Amazon reserves the right to change the price of your book, for any reason, for any length of time, without warning. I even confirmed this with their customer support, because I thought it was too ludicrous to be true. This means that Amazon could decide to sell my book for 99 cents, and the only thing I could do about it was remove it from the store. Those were not terms I was comfortable with.
The Apple iBookStore is quite the opposite. You set the price, Apple gets 30%, and that’s all she wrote. Your book as to be approved, but it also has to have an ISBN, which can cost up to $200. I may still try this, but I’d need to sell 13 copies to people who would otherwise never know about the book to make it break even. And given how un-remarkable it looks on iPad (it looks fine, just not amazing), I’m not sure I’d want to list it there.
Getting the print version into Amazon and other stores is something LuLu can do, but it looks a bit onerous. You need an ISBN (and can’t use the same one for print and iBookStore—each format has to have its own), and your book must meet a laundry list of requirements before having to be approved.
These may turn into viable options, but for now, I’m holding off.
Now that I had a way for people to buy, I needed to get the word out. I didn’t have the publishers website and marketing channels, so I was on my own.
Marketing and Promotion
On launch day, I posted a link on my blog, posted twice on Twitter (once in the morning, once in the afternoon), and submitted links to both Hacker News and Reddit.
Hacker News generated some discussion about how awful my website was (it was awful, since redesigned by a very kind friend), but didn’t generate many conversions (nor did Reddit). Almost all traffic and purchases were from my blog or Twitter. I sold about 100 copies on day 1, which was a good feeling. After that, I’ve been getting a handful of sales every week in steady fashion.
I posted coupon codes on Facebook and LinkedIn for $10 off. This resulted in exactly one sale.
Initially I didn’t accept PayPal, as I didn’t want to deal with them. After some feedback that I might be losing sales, I turned it on, and most of my sales are now via PayPal. I’ve had no problems thusfar.
I’ve written posts on my blog related to the book, with links, however these never generated a noticeable bump in sales. I did a sale on “National Programmer’s Day”, which DID result in a bump (and was clearly worth it, since many of those sales would never have been made). This is one thing that’s nice about going it on your own—you can change course like this any time, and do sales, or change the price pretty much on a whim.
What all this said to me was that I had “tapped out” my social network. I’m proud of the sales I’ve made essentially based on my Twitter followers and blog audience, but I need to do something more to reach a new audience. This is where I’m a bit stumped.
I plan to speak at more conferences, although I have my doubts that this is ultimately worth it, considering the cost of travel. I’ve considered purchasing advertising, however the channels I would find most effective are places that I myself hate seeing ads, so I’m not sure how I feel about that.
Which is better?
As you can see, this is not so straightforward. Going it on my own, I have a lot of freedom, can switch directions, and have complete control over all aspects of the book. The downside, other than having to control those things, is that my personal reach is orders of magnitude lower than the reach of an established publisher.
The downside of a publisher is that I must first choose a topic they wish to publish a book on, and then deal with the process and gate-keeping that goes along with it. But, that process produces a higher quality result. How much higher is unknown.
It’s worth mentioning that it doesn’t seem feasible to make a living entirely on writing tech books. While I’ve made some good money on both efforts, neither would pay the rent or sustain even a modest lifestyle. To do so, I would have to produce very popular books on a frequent schedule. There are very few tech books one would consider “seminal”, and their authors tend to either have day jobs or a more diversified offering of services beyond writing.
All that to say that writing books for me is a side project; something I do in my free time. Because of that, the self-publishing route felt better. It felt more agile, and much simpler.
That being said, I’m still getting royalties on my first book, which is going on two years old. Will I be able to say the same about my current book two years from now?
Too Long, DID Read
This is a long post, but I hope you enjoyed it.  Click here and enter the code TLDR5
in the space labeled “Promo Code” before you buy. Thanks for reading!
- LeanPub is somewhat interesting. They aren’t a traditional publisher, but it’s possible that their name carries some weight with readers. I was looking at them as a toolchain vendor, although they might be interesting to consider as an additional sales channel. ↩


From a couple of gigabytes to several terabytes, 28.io enables your information processing to be deployed instantly and to scale automatically.
No credit card required
399$/month paid annualy
499$ month to month
Tailored to your needs
capacity: maximum volume of data that can be processed per month.
throughput: maximum volume of data that can be processed per minute.
The volume is computed by measuring the amount of data that is read from data sources during processing of the query as well as the amount of data that is returned as a result of the query execution.


{- Acknowledgements ~~~~~~~~~~~~~~~~~~~ * 'prefixF', 'suffixF', 'padBothF', 'groupInt' are taken from <https://hackage.haskell.org/package/formatting> Written by Github user @mwm <https://github.com/mwm> * 'ordinalF' is taken from <https://hackage.haskell.org/package/formatting> Written by Chris Done <https://github.com/chrisdone> * 'atBase' is taken from <https://hackage.haskell.org/package/formatting>, originally from <https://hackage.haskell.org/package/lens> Seems to be written by Johan Kiviniemi <https://github.com/ion1> -} module Fmt ( -- * Overloaded strings -- $overloadedstrings -- * Examples -- $examples -- * Migration guide from @formatting@ -- $migration -- * Basic formatting -- $brackets -- ** Ordinary brackets -- $god1 (+|), (|+), -- ** 'Show' brackets -- $god2 (+||), (||+), -- ** Combinations -- $god3 (|++|), (||++||), (|++||), (||++|), -- * Old-style formatting format, formatLn, Format, -- * Helper functions fmt, fmtLn, pretty, prettyLn, Builder, Buildable(..), -- * Formatters -- ** Time module Fmt.Time, -- ** Text indentF, indentF', nameF, unwordsF, unlinesF, -- ** Lists listF, listF', blockListF, blockListF', jsonListF, jsonListF', -- ** Maps mapF, mapF', blockMapF, blockMapF', jsonMapF, jsonMapF', -- ** Tuples tupleF, -- ** ADTs maybeF, eitherF, -- ** Padding/trimming prefixF, suffixF, padLeftF, padRightF, padBothF, -- ** Hex hexF, -- ** Bytestrings base64F, base64UrlF, -- ** Integers ordinalF, commaizeF, -- *** Base conversion octF, binF, baseF, -- ** Floating-point floatF, exptF, fixedF, -- ** Conditional formatting whenF, unlessF, -- ** Generic formatting genericF, ) where import Formatting.Buildable (Buildable(..)) import Data.Text.Lazy.Builder import Fmt.Internal import Fmt.Time -- $setup -- >>> :set -XOverloadedStrings -- >>> :set -XDeriveGeneric -- >>> import Data.Text (Text) {- $overloadedstrings You need @OverloadedStrings@ enabled to use this library. There are three ways to do it: * __In GHCi:__ do @:set<EMAIL_ADDRESS>* __In a module:__ add @\{\-\# LANGUAGE OverloadedStrings \#\-\}@ to the beginning of your module. * __In a project:__ add @OverloadedStrings@ to the @default-extensions@ section of your @.cabal@ file. -} {- $examples Here's a bunch of examples because some people learn better by looking at examples. Insert some variables into a string: >>> let (a, b, n) = ("foo", "bar", 25) >>> ("Here are some words: "+|a|+", "+|b|+"\nAlso a number: "+|n|+"") :: String "Here are some words: foo, bar\nAlso a number: 25" Print it: >>> fmtLn ("Here are some words: "+|a|+", "+|b|+"\nAlso a number: "+|n|+"") Here are some words: foo, bar Also a number: 25 Format a list in various ways: >>> let xs = ["John", "Bob"] >>> fmtLn ("Using show: "+||xs||+"\nUsing listF: "+|listF xs|+"") Using show: ["John","Bob"] Using listF: [John, Bob] >>> fmt ("YAML-like:\n"+|blockListF xs|+"") YAML-like: - John - Bob >>> fmt ("JSON-like: "+|jsonListF xs|+"") JSON-like: [ John , Bob ] -} {- $migration Instead of using @%@, surround variables with '+|' and '|+'. You don't have to use @sformat@ or anything else, and also where you were using @build@, @int@, @text@, etc in @formatting@, you don't have to use anything in @fmt@: @ formatting __sformat ("Foo: "%build%", bar: "%int) foo bar__ fmt __"Foo: "+|foo|+", bar: "+|bar|+""__ @ The resulting formatted string is polymorphic and can be used as 'String', 'Text', 'Builder' or even 'IO' (i.e. the string will be printed to the screen). However, when printing it is recommended to use 'fmt' or 'fmtLn' for clarity. @fmt@ provides lots of formatters (which are simply functions that produce 'Builder'): @ formatting __sformat ("Got another byte ("%hex%")") x__ fmt __"Got another byte ("+|hexF x|+")"__ @ Instead of the @shown@ formatter, either just use 'show' or double brackets: @ formatting __sformat ("This uses Show: "%shown%") foo__ fmt #1 __"This uses Show: "+|show foo|+""__ fmt #2 __"This uses Show: "+||foo||+""__ @ Many formatters from @formatting@ have the same names in @fmt@, but with added “F”: 'hexF', 'exptF', etc. Some have been renamed, though: @ __Cutting:__ fitLeft -\> 'prefixF' fitRight -\> 'suffixF' __Padding:__ left -\> 'padLeftF' right -\> 'padRightF' center -\> 'padBothF' __Stuff with numbers:__ ords -\> 'ordinalF' commas -\> 'commaizeF' @ Also, some formatters from @formatting@ haven't been added to @fmt@ yet. Specifically: * @plural@ and @asInt@ (but instead of @asInt@ you can use 'fromEnum') * @prefixBin@, @prefixOrd@, @prefixHex@, and @bytes@ * formatters that use @Scientific@ (@sci@ and @scifmt@) They will be added later. (On the other hand, @fmt@ provides some useful formatters not available in @formatting@, such as 'listF', 'mapF', 'tupleF' and so on.) -} ---------------------------------------------------------------------------- -- Documentation for operators ---------------------------------------------------------------------------- {- $brackets To format strings, put variables between ('+|') and ('|+'): >>> let name = "Alice" :: String >>> "Meet "+|name|+"!" :: String "Meet Alice!" Of course, 'Text' is supported as well: >>> "Meet "+|name|+"!" :: Text "Meet Alice!" You don't actually need any type signatures; however, if you're toying with this library in GHCi, it's recommended to either add a type signature or use 'fmtLn': >>> fmtLn ("Meet "+|name|+"!") Meet Alice! Otherwise the type of the formatted string would be resolved to @IO ()@ and printed without a newline, which is not very convenient when you're in GHCi. On the other hand, it's useful for quick-and-dirty scripts: @ main = do [fin, fout] \<- words \<$\> getArgs __"Reading data from "+|fin|+"\\n"__ xs \<- readFile fin __"Writing processed data to "+|fout|+"\\n"__ writeFile fout (show (process xs)) @ Anyway, let's proceed. Anything 'Buildable', including numbers, booleans, characters and dates, can be put between ('+|') and ('|+'): >>> let starCount = "173" >>> fmtLn ("Meet "+|name|+"! She's got "+|starCount|+" stars on Github.") Meet Alice! She's got 173 stars on Github. Since the only thing ('+|') and ('|+') do is concatenate strings and do conversion, you can use any functions you want inside them. In this case, 'length': >>> fmtLn (""+|name|+"'s name has "+|length name|+" letters") Alice's name has 5 letters If something isn't 'Buildable', just use 'show' on it: >>> let pos = (3, 5) >>> fmtLn ("Character's position: "+|show pos|+"") Character's position: (3,5) Or one of many formatters provided by this library – for instance, for tuples of various sizes there's 'tupleF': >>> fmtLn ("Character's position: "+|tupleF pos|+"") Character's position: (3, 5) Finally, for convenience there's the ('|++|') operator, which can be used if you've got one variable following the other: >>> let (a, op, b, res) = (2, "*", 2, 4) >>> fmtLn (""+|a|++|op|++|b|+" = "+|res|+"") 2*2 = 4 Also, since in some codebases there are /lots/ of types which aren't 'Buildable', there are operators ('+||') and ('||+'), which use 'show' instead of 'build': prop> (""+|show foo|++|show bar|+"") == (""+||foo||++||bar||+"") -} -- $god1 -- Operators for the operators god! -- $god2 -- More operators for the operators god! {- $god3 Z̸͠A̵̕͟͠L̡̀́͠G̶̛O͝ ̴̀ I͞S̸̸̢͠ ̢̛͘͢C̷͟͡Ó̧̨̧͞M̡͘͟͞I̷͜N̷̕G̷̀̕ (Though you can just use @""@ between @+| |+@ instead of using these operators, and 'Show'-brackets don't have to be used at all because there's 'show' available.) -} ---------------------------------------------------------------------------- -- TODOs ---------------------------------------------------------------------------- {- docs ~~~~~~~~~~~~~~~~~~~~ * mention that fmt doesn't do the neat thing that formatting does with (<>) (or maybe it does? there's a monoid instance for functions after all, though I might also have to write a IsString instance for (a -> Builder)) * write that if +| |+ are hated or if it's inconvenient in some cases, you can just use provided formatters and <> (add Fmt.DIY for that?) (e.g. "pub:" <> base16F foo) * write that it can be used in parallel with formatting? can it, actually? * clarify what exactly is hard about writing `formatting` formatters -} {- others ~~~~~~~~~~~~~~~~~~~~ * what effect does it have on compilation time? what effect do other formatting libraries have on compilation time? -}


[gecode-users] Problems with some REG and some suggestions
Christian Schulte
cschulte at kth.se
Mon Sep 26 21:42:41 CEST 2011
Hi,
Great that you like Gecode.
Unfortunately there is very little that we can do about 1: the algorithm we
use for turning a regexp into a DFA actually uses that much memory (and it
is not even naïve). Remember: you are creating a DFA with 1000 states
_after_ minimization. The intermediate DFA that is created has millions of
states (any conversion of a regexp directly to a DFA or via a NFA can show
this behavior as the DFA that is constructed might be exponentially larger
than the regexp/NFA). And you artfully picked a pretty bad example ;-)
Maybe there are better algorithms that combine DFA construction with
minimization to deal with the DFAs but for most cases it works fine for
Gecode...
Is your regexp related to a real example or did you want to torture Gecode
;-)
I never thought about operations on DFAs as I thought one would use regexps
anyway. The only hard part is in fact intersection, the rest is very simple.
What do you need them for?
Best
Christian
--
Christian Schulte, KTH, web.it.kth.se/~cschulte/
-----Original Message-----
From: users-bounces at gecode.org [mailto:users-bounces at gecode.org] On Behalf
Of TeXitoi
Sent: Monday, September 26, 2011 8:32 PM
To: users at gecode.org
Subject: [gecode-users] Problems with some REG and some suggestions
Hi,
First, Thanks for you're very good CP library: I enjoy using it.
I have see 1 "bug" and have identified some missing features.
First, I have poblems when I try to generate REG of the form
REG r = *a + a(1000,1000);
It takes a lot of RAM. Here is a main function that show the problem:
#include <gecode/int.hh>
#include <gecode/search.hh>
#include <gecode/minimodel.hh>
using namespace Gecode;
using namespace std;
int main(void)
{
REG any_l = REG(0) | REG(1);
cout << "Generating '.{1000}'..." << flush;
REG bigReg_l = any_l(1000,1000);
cout << " done." << endl;
cout << "Generating DFA(.{1000})..." << flush;
DFA dfa_l(bigReg_l);//OK
cout << " done." << endl;
cout << "Generating '.{1000}.{1000}'..." << flush;
REG veryBigReg_l = bigReg_l + bigReg_l;
cout << " done." << endl;
cout << "Generating DFA(.{1000}.{1000})..." << flush;
dfa_l = DFA(veryBigReg_l);//OK
cout << " done." << endl;
cout << "Generating '.{1000}.*'..." << flush;
veryBigReg_l = bigReg_l + *any_l;
cout << " done." << endl;
cout << "Generating DFA(.{1000}.*)..." << flush;
dfa_l = DFA(veryBigReg_l);//OK
cout << " done." << endl;
cout << "Generating '.*.{1000}'..." << flush;
veryBigReg_l = *any_l + bigReg_l;
cout << " done." << endl;
cout << "Generating DFA(.*.{1000})..." << flush;
dfa_l = DFA(veryBigReg_l);//takes lots of RAM...
cout << " done." << endl;
}
Then, it could be great to have different IntConLevel for the sequence
constraint. In my model, the filtering does not help and takes time, so I
post a count constraint for each interval. It can be useful to have that
with IntConLevel = ICL_VAL. And with IntConLevel = ICL_DOM, the extensional
version (which is exponential).
Finally, DFA operations can be very useful : union, intersection,
concatenation, star and opposite. I already coded intersection and opposite
for my needs (I can show them if you want, but the implementation is quite
naive).
Again, thanks a lot for Gecode!
--
Guillaume Pinot http://www.texitoi.eu
« Il semble que la perfection soit atteinte non quand il n'y a plus rien à
ajouter, mais quand il n'y a plus rien à retrancher. »
-- Antoine de Saint-Exupéry, Terre des hommes
() ASCII ribbon campaign -- Against HTML e-mail
/\ http://www.asciiribbon.org -- Against proprietary attachments
_______________________________________________
Gecode users mailing list
users at gecode.org
https://www.gecode.org/mailman/listinfo/gecode-users
More information about the users
mailing list


Check Nearest Location:
LOCATE ME
Join
Contact Us
Careers
Francais
MENU
(current)
OUR FOOD QUALITY STORY
THE LASTEST
COMMUNITY
LOCATE
SEARCH
Previous
Next
New McCafè Bagels
Baked fresh daily in our restaurants.
Try them today.
New McCafè Bagels
Baked fresh daily in our restaurants.
Try them today.
New McCafè Bagels
Baked fresh daily in our restaurants.
Try them today.
New McCafè Bagels
Baked fresh daily in our restaurants.
Try them today.


This is a paragraph, shown in the Times New Roman font.
This is a paragraph, shown in the Arial font.
This is a paragraph.
This is another paragraph.


Pirates’ Monyane Faces Off Against Micho!
by Soccer LadumaOrlando Pirates youngster Thabiso Monyane faced off against the team of his former coach Milutin Sredojevic on Wednesday.
Monyane is one of the players with the South African Under-23 team in Egypt in preparation for the 2019 U23 Africa Cup of Nations.
Read – Breaking: City Announce New Head Coach
As part of the side's preparation for the competition, David Notoane’s team played a friendly match against Egyptian giants, Zamalek.
Zamalek won the match 2-0, though the focus for Notoane and his technical team was not the score, but the overall performaance of the team and their readiness for the competition.
Following his surprise resignation from Pirates in August, Micho went on to take up a role as the coach of Zamalek.
It was under the Serbian coach that Monyane made his professional debut at the start of the season, following his promotion from the club's junior ranks.
Read: Why Relegation-Threatened Baroka Are Confident...
Notoane’s team and Zamalek played in a closed practice match at the Abdel-Latif Abu-Rajelha Stadium.
The Mzansi youngsters open their AFCON campaign with a match against Zambia this coming Saturday.
The Group B match is scheduled for the Al Salam Stadium from 20h00. The other upcoming Group B matches for SA will be against Ivory Coast and Nigeria.


Profile Information
Profile Name:
Personal Information
First Name:
Middle Name:
Last Name:
Phone number:
E-mail:
Street Address:
City:
Work Experience
Job Title:
Company:
Location:
From Date:
To Date:
Role Description:
Education
School or University:
From Date:
To (Actual or Expected):
Degree:
GPA:
Social Media URLs
LinkedIn:
Github:
Portfolio:
Website:


import numpy as np
from pylj import comp, util
[docs]def initialise(number_of_particles, temperature, box_length, init_conf, timestep_length=5e-3):
"""Initialise the particle positions (this can be either as a square or random arrangement), velocities (based on
the temperature defined, and calculate the initial forces/accelerations.
Parameters
----------
number_of_particles: int
Number of particles to simulate.
temperature: float
Initial temperature of the particles, in Kelvin.
box_length: float
Length of a single dimension of the simulation square, in Angstrom.
init_conf: string, optional
The way that the particles are initially positioned. Should be one of:
- 'square'
- 'random'
timestep_length: float (optional)
Length for each Velocity-Verlet integration step, in seconds.
Returns
-------
System
System information.
"""
system = util.System(number_of_particles, temperature, box_length, init_conf=init_conf,
timestep_length=timestep_length)
v = np.sqrt(2 * system.init_temp)
theta = 2 * np.pi * np.random.randn(system.particles.size)
system.particles['xvelocity'] = v * np.cos(theta)
system.particles['yvelocity'] = v * np.sin(theta)
system.particles, system.distances, system.forces = comp.compute_forces(system.particles, system.distances,
system.forces, system.box_length)
return system
[docs]def velocity_verlet(particles, timestep_length, box_length):
"""Uses the Velocity-Verlet integrator to move forward in time. The
Updates the particles positions and velocities in terms of the Velocity Verlet algorithm. Also calculates the
instanteous temperature, pressure, and force and appends these to the appropriate system array.
Parameters
----------
particles: util.particle_dt, array_like
Information about the particles.
timestep_length: float
Length for each Velocity-Verlet integration step, in seconds.
box_length: float
Length of a single dimension of the simulation square, in Angstrom.
Returns
-------
util.particle_dt, array_like:
Information about the particles, with new positions and velocities.
"""
xposition_store = particles['xposition']
yposition_store = particles['yposition']
[particles['xposition'], particles['yposition']] = update_positions([particles['xposition'],
particles['yposition']],
[particles['xvelocity'],
particles['yvelocity']],
[particles['xacceleration'],
particles['yacceleration']], timestep_length,
box_length)
[particles['xvelocity'], particles['yvelocity']] = update_velocities([particles['xvelocity'], particles['yvelocity']],
[particles['xacceleration'],
particles['yacceleration']], timestep_length)
particles['xprevious_position'] = xposition_store
particles['yprevious_position'] = yposition_store
return particles
[docs]def sample(particles, box_length, initial_particles, system):
"""Sample parameters of interest in the simulation.
Parameters
----------
particles: util.particle_dt, array_like
Information about the particles.
box_length: float
Length of a single dimension of the simulation square, in Angstrom.
initial_particles: util.particle_dt, array-like
Information about the initial particle conformation.
system: System
Details about the whole system
Returns
-------
System:
Details about the whole system, with the new temperature, pressure, msd, and force appended to the appropriate
arrays.
"""
temperature_new = util.calculate_temperature(particles)
pressure_new = comp.calculate_pressure(particles, box_length, temperature_new)
msd_new = util.calculate_msd(particles, initial_particles, box_length)
system.temperature_sample = np.append(system.temperature_sample, temperature_new)
system.pressure_sample = np.append(system.pressure_sample, pressure_new)
system.force_sample = np.append(system.force_sample, np.sum(system.forces))
system.msd_sample = np.append(system.msd_sample, msd_new)
return system
[docs]def update_positions(positions, velocities, accelerations, timestep_length, box_length):
"""Update the particle positions using the Velocity-Verlet integrator.
Parameters
----------
positions: (2, N) array_like
Where N is the number of particles, and the first row are the x positions and the second row the y positions.
velocities: (2, N) array_like
Where N is the number of particles, and the first row are the x velocities and the second row the y velocities.
accelerations: (2, N) array_like
Where N is the number of particles, and the first row are the x accelerations and the second row the y
accelerations.
timestep_length: float
Length for each Velocity-Verlet integration step, in seconds.
box_length: float
Length of a single dimension of the simulation square, in Angstrom.
Returns
-------
(2, N) array_like:
Updated positions.
"""
positions[0] += velocities[0] * timestep_length + 0.5 * accelerations[0] * timestep_length * timestep_length
positions[1] += velocities[1] * timestep_length + 0.5 * accelerations[1] * timestep_length * timestep_length
positions[0] = positions[0] % box_length
positions[1] = positions[1] % box_length
return [positions[0], positions[1]]
[docs]def update_velocities(velocities, accelerations, timestep_length):
"""Update the particle velocities using the Velocity-Verlet algoritm.
Parameters
----------
velocities: (2, N) array_like
Where N is the number of particles, and the first row are the x velocities and the second row the y velocities.
accelerations: (2, N) array_like
Where N is the number of particles, and the first row are the x accelerations and the second row the y
accelerations.
timestep_length: float
Length for each Velocity-Verlet integration step, in seconds.
Returns
-------
(2, N) array_like:
Updated velocities.
"""
velocities[0] += 0.5 * accelerations[0] * timestep_length
velocities[1] += 0.5 * accelerations[1] * timestep_length
return [velocities[0], velocities[1]]


proj/dlcompatProject Lead: Peter O'Gorman, dlcompat is a dlopen(3) et.al. compatibility library for Mac OS X/Darwin. To find out about how to load things natively see the NSModule(3) and related man pages, also look at the dlfcn_simple.c file in cvs. Download the latest dlcompat released on 2003-06-29 here Read the ChangeLog for this release Getting the project from CVS Use the following commands to get the project from the OpenDarwin CVS server:
cvs -d :pserver:anonymous@anoncvs.opendarwin.org:/cvs/od login cvs -d :pserver:anonymous@anoncvs.opendarwin.org:/cvs/od co -d dlcompat proj/dlcompatWhen the server asks you for a password you can simply hit return; the password is empty. Browse the cvs repository for dlcompat here Return to opendarwin |


Max Chao
About
|
Portfolio
|
Contact
Portfolio
Portfolio
Portfolio
Portfolio
Portfolio
Portfolio
Portfolio
Connect with Me
Connect with Me


Pickletrack helps find the closest bars to you in New York City that serve picklebacks. Currently, this includes the four boroughs Manhattan, Brooklyn, Queens, and The Bronx.
Results are selected randomly from bars within three miles, favoring bars that are closer from those further away.
All data is sourced from Foursquare and updated regularly. To have a bar included in the results, add a review mentioning picklebacks to the venue page on Foursquare.
To use the Foursquare API Pickletrack is required to have a privacy policy. Pickletrack receives information from your browser when you access the service, including version, browser type, and operating system information. This information may be used to diagnose issues with the service. This information is shared with Google for analytics purposes. Who knows what they do with the data. Pickletrack accesses your location when you use the service to determine nearby venues. The location information may appear in server logs, but is not otherwise stored or shared with any service, including Google or Foursquare itself. Pickletrack will never use information stored in server logs for any reason except to diagnose issues with the service.
Pickletrack is open source, please submit a pull request with any changes. https://github.com/pantaloons/pickletrack
For any questions, concerns, or suggestions, please contact michael@mcgee.nz


|
Important
This document is not an official Census Bureau publication. It is compiled from publicly accessible information by Lars Vilhuber (Labor Dynamics Institute, Cornell University). Feedback is welcome. Please write us at<EMAIL_ADDRESS>|
1. Purpose
The public-use Quarterly Workforce Indicators (QWI) data from the Longitudinal Employer-Household Dynamics Program are available for download with the following data schema. These data are available as Comma-Separated Value (CSV) files through the LEHD website’s Data page at http://lehd.ces.census.gov/data/ and through LED Extraction Tool at http://ledextract.ces.census.gov/.
This document describes the file naming schema for LEHD-provided CSV files.
2. Schema for Data File Contents
The contents (schema) are described in lehd_public_use_schema.html.
3. Extends
This version extends v4.0. Any file compliant with LEHD or QWI Schema v4.0 will also be compliant with this schema.
4. Basic Schema
All files are preceded by a file type definition, followed by additional information on the aggregation level of the file, or some other identifier.
[TYPE]_[DETAILS].csv
4.1. QWIPU from the LED Extraction Tool
CSV files downloaded through the LED Extraction Tool at http://ledextract.ces.census.gov/ follow the following naming convention:
[type]_[id].csv
where [id]
is the Request ID (a unique string of characters) generated every time Submit Request'' is clicked. The ID references each query submission made to the database.
4.2. Other files
Full CSV files downloaded from the LEHD website at http://lehd.ces.census.gov/data follow the following naming convention:
[type]_[fipsalpha]_[demo]_[fas]_[geocat]_[indcat]_[ownercat]_[sa]
where each component is described in more detail below. Schema files detailing legal values for each component can be downloaded from this website.
5. Description of Filename Components
5.1. Types
( naming_type.csv )
| type | Description | Explanation | url |
|---|---|---|---|
qwi |
Quarterly Workforce Indicators Public Use Counts (QWIPU) |
The Quarterly Workforce Indicators (QWI) are a set of economic indicators including employment, job creation, earnings, and other measures of employment flows. The QWI are reported using detailed firm characteristics (geography, industry, age, size) and worker demographics information (sex, age, education, race, ethnicity). |
5.2. fipsalpha
This component is the alphabetic FIPS state code equivalent to the numeric FIPS code in label_fipsnum.csv, based on FIPS PUB 5-2.
| type | Description |
|---|---|
st |
Any legal 2-character state postal code (see naming_fipsalpha.csv )) |
5.3. demo
( naming_demo.csv )
| type | Description |
|---|---|
d |
All demographics |
rh |
Race by Ethnicity tabulations |
sa |
Sex by Age tabulations |
se |
Sex by Education tabulations |
5.4. fas
( naming_fas.csv )
| type | Description |
|---|---|
f |
All firm sizes and ages |
fa |
Tabulations by firm age |
fs |
Tabulations by firm size |
5.5. geocat
| type | Description |
|---|---|
gc |
Counties |
gm |
Metropolitan/Micropolitan |
gn |
National (50 States + DC) |
gs |
States |
gw |
Workforce Investment Areas |
5.6. indcat
| type | Description |
|---|---|
n |
all industries |
ns |
NAICS sectors |
n3 |
NAICS subsectors |
n4 |
NAICS industry groups |
5.7. owncat
| type | Description |
|---|---|
fg |
Federal government (QWI Code A01) |
op |
All Private (QWI Code A05) |
oslp |
State, local, and private ownership categories (QWI Code A00) |
6. Changes
6.1. This version (revisions)
-
2015-12-22: Initial release
-
2016-03-15: Added better cross-links between CSV naming schame, and datafile schema
-
2016-03-15: Corrected label_geo_level.csv to include the national level value.
6.2. Version 4.0.1 from 4.0
-
2015-02-24: removed obsolete flag values
-
2015-04-01: updated IL, NE geography definitions
6.3. Version 4.0.2 from 4.0.1
-
2015-04-01: switched NAICS coding from 2007 to 2012
6.4. Version 4.0.3 from 4.0.2
-
2015-09-14: switched Geovintage to 2014, updated AK and SD files, added MA.
6.5. Version 4.0.4 from 4.0.3
-
2015-11-30: updated OR.
-
2015-12-10: Added consolidated geography label file label_geography_all.csv
-
2015-12-22: Updated the identification of the correct geo vintage
-
2015-12-22: Added a link to NAICS 2012 tables
-
2015-12-22: Removing the 99 row in industry values - only used for internal error checking


ROI Coin Mining Calculator
Select your mining hardware
or enter your hashrate (H/s)
Earnings per day:
Earnings per week:
Earnings per month:
Network and Exchange Information
Interest Calulation and Scenario Predictions
Enter your initial number of ROI Coin (principal)
Enter the number of days you will commit the coins to a term locked deposit (max 365)
Enter the anticipated future exchange rate in USD
This project is available on GitHub. Term deposit and profit scenario calculations coming soon.
Tips (of any amount at all) are greatly appreciated. Thank you for being awesome and contributing to open-source software.
ROI: RVDhzfZrKvk7z7D4B5D7ncQB2a1mZsJ5gZ
BTC: 1NWfcDQKdbb9YCep4prGCw4cMCpKVt27FL
Exchange data pulled from CoinsMarkets.com
Network data pulled from BlockExplorer.ROI-Coin.com


---
layout: page
title: FreeRADIUS 'man' pages
subtitle: Documentation from the server
subpage: true
navorder: 200
hero: documentation
subnav:
- text: Programs
link: '/radiusd/man/#programs'
- text: Configuration Files
link: '/radiusd/man/#files'
- text: Modules
link: '/radiusd/man/#modules'
---
rlm_passwd
Section: FreeRADIUS Module (5)
Updated: 20 January 2015
Index
Return to Main Contents
NAME
rlm_passwd - FreeRADIUS Module
DESCRIPTION
The
rlm_passwd module provides authorization via files similar
in format to /etc/passwd.
This module allows you to retrieve any account information from any
files with passwd-like format (/etc/passwd, /etc/group,
smbpasswd, .htpasswd, etc). Every field of the file may be mapped to
a RADIUS attribute, with one of the fields used as a key.
The module reads the file when it initializes, and caches the data in
memory. This makes it very fast, even for files with thousands of
lines. To re-read the file the module will need to be reloaded with
radmin(8), or the server will need to be sent a SIGHUP, as
dynamic updates are not supported.
CONFIGURATION
The configuration item(s):
- allow_multiple_keys
-
If set to 'yes', and more than one record in file matches the request,
then the attributes from all records will be used. If set to 'no' (the
default) the module will warn about duplicated records.
- delimiter = :
-
The character to use as a delimiter between fields. The default is
":"
- filename
-
The path to the file.
- format
-
The format of the fields in the file, given as an example line from
the file, with the content of the fields as the RADIUS attributes
which the fields map to. The fields are separated by the ':' character
in the configuration (no matter what is configured for the 'delimiter'
option).
- hash_size
-
The size of the hash table. A larger value means less probability of a
collision so records will be found faster, at the expense of greater
memory usage. Having a hash_size in the range of 30-100% of the number
of passwd file records is reasonable.
- ignore_empty
-
When set to "yes", the default, empty fields in the input will be
skipped and the RADIUS attribute will not be added. By setting this
value to "no", all attributes in the format list will always be added,
even if they have no value.
- ignore_nislike
-
If set to 'yes', then all records from the file beginning with the '+'
sign will be ignored. The default is 'no'.
FORMAT
The
format option controls how lines are read from the file, and
which fields are mapped to which RADIUS attributes.
The key field is the field being searched for within the file. It is
normally signified by being preceded with a '*' character, which
indicates that the field has only one key, like the /etc/passwd file.
The key field may instead be preceded with '*,', which indicates that
the field has multiple possible comma-separated keys, such as when
searching the /etc/group file.
The other fields signify RADIUS attributes. By default they will be
added as a control attribute list.
To add an attribute to the RADIUS request (as though it had been sent
by the NAS), prefix the attribute name in the "format" string with the
'~' character.
To add an attribute to the RADIUS reply (to be sent back to the NAS),
prefix the attribute name in the "format" string with the '='
character.
EXAMPLES
-
format = "*User-Name:Crypt-Password:"
-
For a file the looks similar to /etc/passwd. The first field,
User-Name, is the key to look up in the file. When the record is
found, a control attribute, 'Crypt-Password', will be added with the
contents of the second field. (Note this will not work with shadow
passwords.)
-
format = "My-Group:::*,User-Name"
-
Parse a file similar to the /etc/group file. An entry matches a
request when the name in a User-Name attribute exists in the
comma-separated list of a line in the file. When an entry matches,
a "My-Group" attribute will be created and added to the control
items for the request. The value of that attribute will be taken from
the first field of the matching line in the file.
-
The ":::" in the format string means that there are extra two fields
in the line, in between the group name and list of user names. Those
fields do not map to any RADIUS attribute, and are therefore ignored.
-
For this example to work in practice, you will have to add the
My-Group attribute to the dictionary file. See dictionary(5)
for details on how this may be done.
-
format = "~My-Group:::*,User-Name"
-
Similar to the previous entry, except the My-Group attribute is added
to the request, as though it was sent by the NAS.
SECTIONS
authorize
FILES
/etc/raddb/mods-available/passwd
SEE ALSO
radiusd(8),
radiusd.conf(5),
radmin(8),
dictionary(5),
rlm_unix(5)
AUTHOR
Alan DeKok <
<EMAIL_ADDRESS>Matthew Newton
<
<EMAIL_ADDRESS>Index
- NAME
-
- DESCRIPTION
-
- CONFIGURATION
-
- FORMAT
-
- EXAMPLES
-
- SECTIONS
-
- FILES
-
- SEE ALSO
-
- AUTHOR
-
This document was created by
man2html,
using the manual pages.
Time: 17:19:42 GMT, March 12, 2018


This scenario demonstates using CSS to customize the styling for DatePicker and TimePicker controls.
Create Styled Controls


Introduction
Load Data
Classification Task
Five-Component PCA
Impact of Number of Components
This notebook will illustrate the use of principal components analysis (PCA) to reduce the dimensionality of a data set, and combine PCA with a state vector classifier (SVC) to classify digits using this lower-dimensional representation.
The data set utilized is a handwritten digits data set provided by the UCI Machine Learning repository and consists of 8x8 optical scans of handwritten digits, together with labels of the correct digit.
For a $d$-dimensional input vector, PCA attempts to find a lower-dimensional representation that minimizes the amount of variance lost by lowering the dimensionality.
%matplotlib inline
# numbers
import numpy as np
import pandas as pd
# plots
import matplotlib.pyplot as plt
from matplotlib.pyplot import *
import seaborn as sns
# utils
import os, re
from pprint import pprint
# learn you some machines
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
from sklearn.svm import SVC
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.model_selection import cross_val_score
from sklearn.metrics import confusion_matrix
The data set consists of 8x8 bitmap images of handwritten digits, with a file for a training set and a file for a testing set.
testing_df = pd.read_csv('data/optdigits/optdigits.tes',header=None)
X_testing, y_testing = testing_df.loc[:,0:63], testing_df.loc[:,64]
training_df = pd.read_csv('data/optdigits/optdigits.tra',header=None)
X_training, y_training = training_df.loc[:,0:63], training_df.loc[:,64]
print X_training.shape
print y_training.shape
mat = X_training.loc[0,:].reshape(8,8)
print mat
plt.imshow(mat)
gca().grid(False)
plt.show()
To perform PCA it's best to normalize our data so it has a mean of 0 and a variance of 1:
def get_normed_mean_cov(X):
X_std = StandardScaler().fit_transform(X)
X_mean = np.mean(X_std, axis=0)
## Automatic:
#X_cov = np.cov(X_std.T)
# Manual:
X_cov = (X_std - X_mean).T.dot((X_std - X_mean)) / (X_std.shape[0]-1)
return X_std, X_mean, X_cov
X_std, X_mean, X_cov = get_normed_mean_cov(X_training)
X_std_validation, _, _ = get_normed_mean_cov(X_testing)
# Make PCA
pca2 = PCA(n_components=2, whiten=True)
pca2.fit(X_std)
X_red = pca2.transform(X_std)
Now that we have reduced the number of dimensions from 64 to 2, we can pass the the reduced dimensional data to a state vector classifier, and fit the reduced inputs to the desired system response.
# Make SVC
linclass2 = SVC()
linclass2.fit(X_red,y_training)
Because we used a 2-component PCA, we can project the original data from high-dimensional space into lower-dimensional principal component space (the subspace projection). We can color each data point by its corresponding digit class, and in this way get a visual sense of how well these classes have been separated in principal component space.
(Remember: we're asking a lot of our PCA model - reducing 64 dimensions to 2 is no mean feat!)
# To color each point by the digit it represents,
# create a color map with 10 elements (10 RGB values).
# Then, use the system response (y_training), which conveniently
# is a digit from 0 to 9.
def get_cmap(n):
#colorz = plt.cm.cool
colorz = plt.get_cmap('Set1')
return [ colorz(float(i)/n) for i in range(n)]
colorz = get_cmap(10)
colors = [colorz[yy] for yy in y_training]
scatter(X_red[:,0], X_red[:,1],
color=colors, marker='*')
xlabel("Principal Component 0")
ylabel("Principal Component 1")
title("Handwritten Digit Data in\nPrincipal Component Space",size=14)
show()
Now that we've reduced the input dimensionality and built a classifier model to classify digits based on the lower-dimensional representation, we can use the validation set to see how well the model does at classifying handwritten digits. First we transform our high-dimensional validation data to low-dimensional principal component space, then we feed the low-dimensional input to the SVC.
# Now see how good it is:
# Use the PCA to fit the validation data,
# then use the classifier to classify digits.
X_red_validation = pca2.transform(X_std_validation)
yhat_validation = linclass2.predict(X_red_validation)
y_validation = y_testing
Next, we visualize the results using a confusion matrix: this visualizes the predicted class on the y-axis and the actual class on the x-axis. All of our correct digits will line up on the diagonal, while an examination of other hotspots in the confusion matrix will reveal any digits that are commonly mistaken for others (for example, we see that our model does a pretty terrible job of identifying the digit 5).
pca2_cm = confusion_matrix(y_validation,yhat_validation)
sns.heatmap(pca2_cm, square=True, cmap='inferno')
title('Confusion Matrix:\n2-Component PCA + SVC')
ylabel('True')
xlabel('Predicted')
show()
Given the amount of information we're trying to cram into our two components, we would expect this model to do a pretty dismal job, and indeed it does. But it does better than we might expect a 2-component model to do.
total = pca2_cm.sum(axis=None)
correct = pca2_cm.diagonal().sum()
print "2-Component PCA Accuracy: %0.2f %%"%(100.0*correct/total)
Once we analyze results, it is useful to quantify the amount of variance in the original data that was lost by the PCA transformation. To do this we can use either the explained variance, or we can back-project the lower-dimensional representation to higher-dimensional space and compare the original to the back-projected high-dimensional input vectors. If we do the latter, we see the error is rather large:
# MSE associated with back-projection:
X_orig = X_std
X_hat = pca2.inverse_transform( pca2.transform(X_orig) )
mse = ((X_hat - X_orig)**2).mean(axis=None)
print mse
This is a pretty significant difference - MSE should be somewhere between 0 (no error) and 1 (all error). Think of it like having an $R^2$ value of 0.25.
To increase the accuracy of the SVC, we need to add more principal components. Performing a 5-component PCA leads to a big improvement in the model's performance:
# Make PCA
pca5 = PCA(n_components=5, whiten=True)
pca5.fit(X_std)
X_red = pca5.transform(X_std)
# Make SVC
linclass5 = SVC()
linclass5.fit(X_red,y_training)
# Use the PCA to fit the validation data,
# then use the classifier to classify digits.
X_red_validation = pca5.transform(X_std_validation)
yhat_validation = linclass5.predict(X_red_validation)
y_validation = y_testing
pca5_cm = confusion_matrix(y_validation,yhat_validation)
sns.heatmap(pca5_cm, square=True, cmap='inferno')
title('Confusion Matrix:\n5-Component PCA + SVC')
show()
total = pca5_cm.sum(axis=None)
correct = pca5_cm.diagonal().sum()
print "5-Component PCA Accuracy: %0.2f %%"%(100.0*correct/total)
Let's take a look at the impact of the number of components on both the PCA and the SVC. Start with the most important thing: whether the predictions are correct. The impact of number of principal components can be plotted against the percent accuracy of the classifier. Next, the back-projection error introduced by PCA will be analyzed as a function of number of components. We will show that this is nearly identical to the explained variance of the PCA analysis.
We'll do this by looping over a number of components. For each specified number of principal components, we will construct a PCA model and fit it, and build an SVC model and fit it, and we'll store the percent accuracy of the SVC and the back-projection error of the PCA model.
def pca_mse_accuracy(n):
"""
Creates a PCA model with n components,
reduces the dimensionality of the validation data set,
then computes two error metrics:
* Percent correct predictions using linear classifier
* Back-projection error (MSE of back-projected X minus original X)
"""
X_std, _, _ = get_normed_mean_cov(X_training)
X_std_validation, _, _ = get_normed_mean_cov(X_testing)
#########
# Start by making PCA/SVC
# Train on training data
# Make PCA
pca = PCA(n_components=n, whiten=True)
pca.fit(X_std)
X_red = pca.transform(X_std)
# Make SVC
linclass = SVC()
linclass.fit(X_red,y_training)
########
# Now transform validation data
# Transform inputs and feed them to linear classifier
y_validation = y_testing
X_red_validation = pca.transform(X_std_validation)
yhat_validation = linclass.predict(X_red_validation)
# Evaluate confusion matrix for predictions
cm = confusion_matrix(y_validation,yhat_validation)
total = cm.sum(axis=None)
correct = cm.diagonal().sum()
accuracy = 1.0*correct/total
# MSE associated with back-projection:
X_orig = X_std
X_hat = pca.inverse_transform( pca.transform(X_orig) )
mse = ((X_hat - X_orig)**2).mean(axis=None)
return mse, accuracy
mses = []
accuracies = []
N = 33
for i in range(1,N):
m, a = pca_mse_accuracy(i)
print "%d-component PCA: MSE = %0.4g, Accuracy = %0.2f"%(i,m,a*100.0)
mses.append((i,m))
accuracies.append((i,a))
mses = np.array(mses)
accuracies = np.array(accuracies)
Obviously this is only one set of parameters, and the problem could be solved with many variations in the models used. However, this gives a sense of how the accuracy of the model increases as we add additional components.
# Now plot the accuracy
plt.plot(accuracies[:,0],accuracies[:,1],'bo-')
plt.title("Percent Correct: Accuracy of Predictions",size=14)
plt.xlabel("Number of Principal Components")
plt.ylabel("Percent Correct")
plt.show()
back-projection analysis with explained variance.
Nmax = 64
pcafull = PCA(n_components=Nmax, whiten=True)
_ = pcafull.fit(X_std)
explained_var_sum = pcafull.explained_variance_.sum()
explained_var = np.cumsum(pcafull.explained_variance_[:N])
explained_var /= explained_var_sum
plot(mses[:,0],mses[:,1],'-o',label='MSE')
plot(mses[:,0],1.0-mses[:,1],'-o',label='1.0 - MSE')
plot(range(1,len(explained_var)+1),explained_var,'-o',label='Expl Var')
xlabel('Number of Principal Components')
ylabel('')
title('Mean Square Error, Principal Components Analysis')
legend(loc='best')
show()
While the explained variance isn't exactly $1 - MSE$, it's pretty close. Since the explained variance is a lot easier to get anyway, it's the better of the two to use to measure how much variance in the original dataset is retained when reducing to $N$ principal components.
In this notebook we utilized principal components analysis (PCA) to reduce the dimensionality of the handwritten digits data set, and passed this to a state vector classifier (SVC) to classify which digit was written. The state vector classifier achieved 83% accuracy with only four principal components; the image data set lends itself well to dimensionality reduction. In another notebook we analyze the reduced dimensional subspace and back-project it to look at the topology for different clusters (and what the topology looks like in areas where there are no data!).


%UseLnInsteadOfLog
TurnOffRules("ConvertShortDenominatorToNegativePower");
a=RandomInteger((-4,-1),(1,4));
b=RandomInteger{}(-5,5);
c=RandomInteger{}(-5,5);
f = b/(x-c) +a;
theX = RandomInteger((-3,-1),(1,3));
leftPoint=c - |theX-c|-5;
rightPoint=c + |theX-c|+5;
theY=(x=theX; f)_2;
theDerivative=d/dx f;
theSlope=(x=theX; theDerivative)_2;
basicPlot=
Plot2D(f, leftPoint, c-0.1, red)
+Plot2D(f, c+0.1, rightPoint, red)
+PlotPoint((theX, theY), blue)
+PlotWindow(300,300);
basicPlot
+PlotSetId("canvas1")
Find the equation of the tangent to
\(y=\displaystyle f\)
at the point \displaystyle (theX, theY).
Your answer should be a line equation, of the form \(y-y_0=a(x-x_0)\) or equivalent.
Answer:
(not (CoefficientOf{}(y, EqualityToArithmeticExpression{}(AlgebraAnswer))==0))
and
(
(
(y-theY - theSlope(x-theX)) CoefficientOf{}(y, EqualityToArithmeticExpression{}(AlgebraAnswer) )
-
EqualityToArithmeticExpression{}(AlgebraAnswer)
)
==0
)
EnsureExpressionDependsOnlyOn{}(AlgebraAnswer, x, y)
%PlotShowJavascriptOnly
basicPlot
+PlotSegment (
(leftPoint, (x=leftPoint; SolveFor(y, AlgebraAnswer) )_2 ),
(rightPoint, (x=rightPoint; SolveFor(y, AlgebraAnswer) )_2 ),
blue )
+PlotSetId("canvas1")
TurnOffRules("DistributeMultiplication", "DistributeMultiplicationConstants");
y-theY= theSlope(x-theX)


Malacañang says emergency powers for Build, Build, Build too late, not priority
'We only have less than 3 years left in office,' says Presidential Spokesman Salvador Panelo
by Rappler.comSubscribe
Email Address
Newsletters
- Glenda Gloria's Take this Tuesday
- Huddle by Miriam Grace Go
- The Newsbreak Agenda by Chay Hofileña
- Sometimes, all you need is video by Lilibeth Frondoso


My Blog
Home
About
Course Certificit
Education
Projects
Contact
Nikita Wawale
Welcome To My Blog
This Is About Me....
Hello.....
I am Nikita Bhagwat Wawale My current education status is I am a engineering student from the Amrutvahini College of engineering sangmner
I have done my Schooling in 2015 with 82% ,then i did my 12th from Agasti college Akole with 55%
My strenghts are my attitude that i like to take challenges that I CAN do...ti my way of thinking that i take both success and failure And the my weakness is time Management issue
My short term goal isi want a such platform where i can grow my career And my long term goal is the i want to be one of the successful software developer
My ehic is "I never neglect an opportunity for my improvement".
Certificates
My achivement
C Programming
Java
Certificat
About My Education
SSC
School Education
HSC
College Education
Engineering
Under Graduation
Projects
Contact Me
I love conversations. let us talk!


Preparation time
less than 30 mins
Cooking time
10 to 30 mins
Serves
6
A pasta carbonara with a special summer treat of fresh asparagus spears. Ready in no time, and such a luxury.
Bring a large pan of water to the boil. Add the fettuccine and cook according to packet instructions.
While the pasta is cooking, heat a large frying pan over a high heat and add the vegetable oil. Add the bacon and fry for 3-4 minutes, until golden-brown. Season with freshly ground black pepper.
Cut the asparagus into 3cm/1in pieces and add to the pan with the bacon. Cook for 1-2 minutes, just to warm through.
Break the eggs into a bowl and break the yolks with a fork.
Drain the cooked pasta and return to the pan it was cooked in. Retain a splash of the water the pasta was cooked in.
Add the bacon and asparagus mixture, including any cooking oils from the pan. Toss well to combine over a low heat. Cook for one minute, then add the egg, parmesan and the reserved cooking water and cook for 30 seconds to one minute, stirring constantly, until the egg is just cooked.
Add the chopped parsley and spoon equal portions into six bowls. Grate over a little extra parmesan and serve.


A configuration describing how the lock screen should be used by the internal SDL system for your application. This configuration is provided before SDL starts and will govern the entire SDL lifecycle of your application.
Describes when the lock screen will be displayed. Defaults to SDLLockScreenConfigurationDisplayModeRequiredOnly
.
@property (nonatomic) SDLLockScreenConfigurationDisplayMode displayMode;
var displayMode: SDLLockScreenConfigurationDisplayMode { get set }
If YES, then the lock screen can be dismissed with a downward swipe on compatible head units. Requires a connection of SDL 6.0+ and the head unit to enable the feature. Defaults to YES.
@property (nonatomic) BOOL enableDismissGesture;
var enableDismissGesture: Bool { get set }
If YES, then the lockscreen will show the vehicle’s logo if the vehicle has made it available. If NO, then the lockscreen will not show the vehicle logo. Defaults to YES.
@property (nonatomic) BOOL showDeviceLogo;
var showDeviceLogo: Bool { get set }
The background color of the lock screen. This could be a branding color, or leave at the default for a dark blue-gray.
@property (nonatomic, copy, readonly) UIColor *_Nonnull backgroundColor;
@NSCopying var backgroundColor: UIColor { get }
Your app icon as it will appear on the lock screen.
@property (nonatomic, copy, readonly, nullable) UIImage *appIcon;
@NSCopying var appIcon: UIImage? { get }
A custom view controller that the lock screen will manage the presentation of.
@property (nonatomic, strong, readonly, nullable) UIViewController *customViewController;
var customViewController: UIViewController? { get }
Initializer unavailable
- (nonnull instancetype)init;
Use this configuration if you wish to manage a lock screen yourself. This may be useful if the automatic presentation feature of SDLLockScreenManager is failing for some reason.
+ (nonnull instancetype)disabledConfiguration;
class func disabled() -> Self
The configuration
Use this configuration for the basic default lock screen. A custom app icon will not be used.
+ (nonnull instancetype)enabledConfiguration;
class func enabled() -> Self
The configuration
Use this configuration to provide a custom lock screen icon and a custom background color, or nil if you wish to use the default background color. This will use the default lock screen layout.
+ (nonnull instancetype)
enabledConfigurationWithAppIcon:(nonnull UIImage *)lockScreenAppIcon
backgroundColor:
(nullable UIColor *)lockScreenBackgroundColor;
class func enabledConfiguration(withAppIcon lockScreenAppIcon: UIImage, backgroundColor lockScreenBackgroundColor: UIColor?) -> Self
The app icon to be shown on the lock screen
The color of the lock screen background
The configuration
Use this configuration if you wish to provide your own view controller for the lock screen. This view controller’s presentation and dismissal will still be managed by the lock screen manager. Note that you may subclass SDLLockScreenViewController and pass it here to continue to have the vehicle icon set to your view controller by the manager.
+ (nonnull instancetype)enabledConfigurationWithViewController:
(nonnull UIViewController *)viewController;
class func enabledConfiguration(with viewController: UIViewController) -> Self
The view controller to be managed
The configuration


I knew my grandparents Mordecai Harvey and Louisa Belle Warner. Even though they are gone, their memory lingers. They taught the children in their family to do what is right. I know that is also true about my parents. The notes, letters and records they kept provide us with a clue as to how they lived life during the early part of the twentieth century. Life was a challenge with both rewards and difficulties, and the kind of love they shared as a family gave them spiritual energy, strength and joy.
When I look at my collection of books and booklets about the Warners written by several of my relatives I wonder if some of us have a kind of gene for genealogy. Perhaps it is the realization that we have come from a good and loving family that makes so many of us want to tell about it. Perhaps because those before us cared and shared we also want to care and share. Many of us highly value family.
Who are we? We know who we are. We are descended from those people who got up
and went to work in
Many have contributed to the ongoing story of our Warner family. I have assembled this story from the following works: Harold W. Osler, History of the Warner Family, 1935; Esther M. Winget, Descendants of William and Ann (Dyde) Warner, 1954; Fran Kigans, Descendants of John Lewis and Charity Wells Warner, 1979; James Hubert Warner, Autobiography, 1982; Eskham and Ethel Hayes, A Little Bird Told Us, 1995; Harvey V. Warner, The Descendants of Mordecai Harvey Warner and Louisa Belle Gilmore, 2004; Elvira Mae (Warner) Covey ,Memories in the Kitchen, 2004; Shelia Elaine McNamara Graham, Family Cookbook, 2005; and a computer printout compiled by Dorothy (Warner) and son, Mark Stoyer, who listed and numbered our known generations. Some material was collected from interviews, some from memories, and occasionally, a little creative imagination may be apparent.
Our story is unending and I encourage others to gather and record their family stories before they are gone. Print and save the stories and pictures of family!
THE WARNER NAME
Warner is an ancient name whose history on English soil
dates back to the wave of emigration that followed the Norman Conquest of
England in 1066. The name comes from Warnier, a
Germanic personal name. It is composed of two elements: warin,
which means guard; and hari, which means soldier.
Such militaristic names were popular in the early Middle
Ages in Europe, which is not surprising given that
Go to Chapter:
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
12, 13,
14, 15,
16, 17


Loading Panels...
Settings
Channels:
Nick:
ClientID:
OAuth:
Transparent:
Image CSS:
Debugging:
Disabled
Debug
Trace
No Force:


Deep learning, Agent-based modelling, Pedestrian simulation, Parallel Computing, Graphics Processing Units (GPUs) and Virtual reality.
Deep learning, Agent-based modelling, Pedestrian simulation, Parallel Computing, Graphics Processing Units (GPUs) and Virtual reality.


Something about seattle
This is a test
Home
Seahawks
Sounders
Mariners
Follow me on twitter
Seahawks
The Champs!
Sounders
The lesser known team
Mariners
The Joke...


This part covers topics that are of interest to a PostgreSQL database administrator. This includes installation of the software, set up and configuration of the server, management of users and databases, and maintenance tasks. Anyone who runs a PostgreSQL server, even for personal use, but especially in production, should be familiar with the topics covered in this part.
The information in this part is arranged approximately in the order in which a new user should read it. But the chapters are self-contained and can be read individually as desired. The information in this part is presented in a narrative fashion in topical units. Readers looking for a complete description of a particular command should see Part VI.
The first few chapters are written so they can be understood without prerequisite knowledge, so new users who need to set up their own server can begin their exploration with this part. The rest of this part is about tuning and management; that material assumes that the reader is familiar with the general use of the PostgreSQL database system. Readers are encouraged to look at Part I and Part II for additional information.


Toggle navigation
FAQ
SHOWROOM
SIGN IN
|
Dealer site
My page
John Yun
Profile
Change Password
My Profile
ACT
NSW
NT
QLD
SA
VIC
WA
Change
Change Password
Change


- The Alchemy Tour
Since the first day of EDC Las Vegas this year, fans have known that Seven Lions, NGHTMRE, SLANDER, and Glitch Mob would be going on the Alchemy Tour together, but only one show was announced at the time. Earlier this week, another show was announced in Seattle, but there was still no clue as to what other cities they would be touring too. Recently, the tour dates for the Alchemy Tour were officially released and you are going to want to make it to a city near you to catch this once in a lifetime tour.


SpeakEasy
About
Contact
Presentation Statistics
All Sentences
(Sentences which are red-bordered are off-target)
Image Emotional Analysis


|
||||||||||
| PREV NEXT | FRAMES NO FRAMES |
| Packages that use org.jgentleframework.context.aop | |
|---|---|
| org.jgentleframework.context.aop | |
| org.jgentleframework.context.aop.support | |
| org.jgentleframework.core.intercept.support |
| Classes in org.jgentleframework.context.aop used by org.jgentleframework.context.aop | |
|---|---|
| ClassFilter
Filter that restricts matching of a pointcut or introduction to a given set of target classes. |
|
| ConstructorFilter
Filter that restricts matching of a pointcut or introduction to a given set of target Constructor . |
|
| FieldFilter
The Interface FieldFilter. |
|
| Filter
The Interface Filter. |
|
| MethodFilter
Filter that restricts matching of a pointcut or introduction to a given set of methods. |
|
| ParameterFilter
Filter that restricts matching of a pointcut or introduction to a given set of parameters corresponding to an given set of methods. |
|
| Pointcut
Core JGentle pointcut abstraction. |
|
| PointcutOfClassFilter
Represents the ClassFilter pointcut. |
|
| PointcutOfConstructorFilter
Represents the ConstructorFilter pointcut. |
|
| PointcutOfFieldFilter
Represents the FieldFilter pointcut. |
|
| PointcutOfMethodFilter
Represents the MethodFilter pointcut. |
|
| PointcutOfParameterFilter
Represents the ParameterFilter pointcut. |
|
| RuntimeSupportFilter
Represents a runtime support filter. |
|
| TrueFieldFilter
Canonical FieldFilter instance that matches all Field . |
|
| TrueMethodFilter
Canonical MethodFilter instance that matches all Method . |
|
| TrueParameterFilter
Canonical ParameterFilter instance that matches all parameters of all
methods. |
| Classes in org.jgentleframework.context.aop used by org.jgentleframework.context.aop.support | |
|---|---|
| Pointcut
Core JGentle pointcut abstraction. |
| Classes in org.jgentleframework.context.aop used by org.jgentleframework.core.intercept.support | |
|---|---|
| ClassFilter
Filter that restricts matching of a pointcut or introduction to a given set of target classes. |
|
| ConstructorFilter
Filter that restricts matching of a pointcut or introduction to a given set of target Constructor . |
|
| FieldFilter
The Interface FieldFilter. |
|
| Filter
The Interface Filter. |
|
| MethodFilter
Filter that restricts matching of a pointcut or introduction to a given set of methods. |
|
| ParameterFilter
Filter that restricts matching of a pointcut or introduction to a given set of parameters corresponding to an given set of methods. |
|
| Pointcut
Core JGentle pointcut abstraction. |
|
| PointcutOfAll
Represents all pointcut. |
|
| PointcutOfClassFilter
Represents the ClassFilter pointcut. |
|
| PointcutOfConstructorFilter
Represents the ConstructorFilter pointcut. |
|
| PointcutOfFieldFilter
Represents the FieldFilter pointcut. |
|
| PointcutOfMethodFilter
Represents the MethodFilter pointcut. |
|
| PointcutOfParameterFilter
Represents the ParameterFilter pointcut. |
|
| RuntimeSupportFilter
Represents a runtime support filter. |
|
||||||||||
| PREV NEXT | FRAMES NO FRAMES |


The first service for the service, click here to continue. Thank you
The second service for the service, click here to continue. Thank you
The thrid service for the service, click here to continue. Thank you
some tags or text goes here.
some tags or text goes here.
some tags or text goes here.
some tags or text goes here.
some tags or text goes here.
some tags or text goes here.


Open Notes
| Status |
Date |
Note |
View Detail |
View Customer |
| {{ note.GSI1PK }} |
{{ note.GSI1SK }} |
{{ note.Note }} |
|
|
| Note |
|
| Date |
{{ note?.GSI1SK }} |
| Status |
{{ note?.GSI1PK }} |
| Note |
{{ note?.Note }} |
|
Client |
| Id |
{{ customer?.PK }} |
| Name |
{{ customer?.GSI1PK }} |
| Address1 |
{{ customer?.Address1 }} |
| Address2 |
{{ customer?.Address2 }} |
| Phone1 |
{{ customer?.Phone1 }} |
| Phone2 |
{{ customer?.Phone2 }} |
| Email |
{{ customer?.Email }} |
| inCharge |
{{ customer?.InCharge }} |
| Notes |
{{ customer?.Notes }} |


| Ticket Number | Category | Sub-Category | Status | Assigned to | Description |
|---|---|---|---|---|---|
| {{ticket.category}} | {{ticket.subcategory}} | {{ticket.status}} |
Click to See Description |
| Ticket Number | Category | Sub-Category | Status | Assigned to | Description |
|---|---|---|---|---|---|
| {{ticket.category}} | {{ticket.subcategory}} | {{ticket.status}} |
Click to See Description |


%inherit file="base.html"/> <%def name="title()"> Welcome to Extrasolar! %def> <%def name="head()"> %def>
|
With the reach of the Internet, the eXoplanetary Research Institute (XRI) is crowdsourcing exploration of Epsilon Prime. With your assistance, we can unlock the secrets of this alien world, one photo at a time.
% if gift_error is not UNDEFINED:
${gift_error}
% endif
% if invite is not UNDEFINED: ${invite.sender.first_name} ${invite.sender.last_name} has invited you to participate. % endif % if gift is not UNDEFINED: This exclusive invitation includes paid access to Extrasolar at the following level: ${gift.name}: ${gift.description}. %endif % if gift_error is UNDEFINED: % endif |


TN will continue to have full control of Mullaiperiyar dam: Gajendra Shekhawat
Shekhawat said the dam safety bill will not alter the existing arrangement of dam ownership, its operation and maintenance, and the water rights of Tamil Nadu.
NEW DELHI: The Tamil Nadu government will continue to have full control on regular operations and maintenance of the Mullaiperiyar dam and the dam safety bill will not alter existing arrangements, Jal Shakti Minister Gajendra Singh Shekhawat said on Monday.
Talking to reporters here after meeting a delegation of AIADMK MPs, Shekhawat said the bill will not alter the existing arrangement of dam ownership, its operation and maintenance, and the water rights of Tamil Nadu.
In the present bill, the state dam safety organisation of Kerala will have no jurisdiction over the Mullaiperiyar dam or other reservoirs of Tamil Nadu, he added.


A thing I do all the time is:
- take a screenshot of a window
- open up GIMP
- crop to the relevant parts
- share the screenshot as a bug or email attachment
The “take a screenshot” step is actually:
- Fire up GNOME Do
- Type “s c r RET”
- Select “Grab the current window”
- Click “Take screenshot”
Is there a faster way of doing this? I particularly want to speed up the cropping and grabbing steps.
cd ~/grabs && scrot -s %Y%m%d%H%M%S.png
- Fire the script = Clik the icon
- draw a rectangular on screen of the part you want to "shot"
- upload it to your bugtracker easily by having a nautilus bookmark pointing to ~/grabs
It even has a handy 'redo' button so you can take a snapshot of the same area/window/menu/tooltip over and over…
http://shutter-project.org/
1. Invoke gnome-do and type 'take'
2. Down arrow twice, tab three times, enter (this selects 'select area to grab' and completes the screenshot dialog)
3. Left click and drag to select area for screenshot
4. Name file / save somewhere in the dialog.
In particular, scrot -s allows to capture a full window by clicking on it or a zone if you move before releasing the button.
You can easilly make a small script to launch scrot with this option and open the resulting file in a viewer. It can still be launched using gnome-do if the script is in your $PATH :)


✕
search
Browse Events
Easily browse around your own personalized eventsfeed as well as our notification system will keep you updated with your favourite events
supervised_user_circle
Speakers
Easily contact and negotiate with location managers to host an event.
location_searching
Locations
Manage your own locations and gain exposure by hosting events with various speakers
subscriptions
Subscribe
Become our premium member and gain access to various events' videos and presentation slides.


Discord Auto-Post
You are not authenticated via Twitter. Click
here
to sign in.
Signed in as [user].


C.5 Finding Codepoints
Each Unicode character is identified by a unique codepoint. You can find information on character codepoints on official Unicode Web sites, but a quick way to look at visual forms of characters is by generating an HTML page with charts of Unicode characters. The script below does this:
mk_unicode_chart.py
# Create an HTML chart of Unicode characters by codepoint
import sys
head = '<title>Unicode Code Points</title>\n' +\
'<META HTTP-EQUIV="Content-Type" ' +\
'CONTENT="text/html; charset=UTF-8">\n' +\
'\n
Unicode Code Points
'
foot = ''
fp = sys.stdout
fp.write(head)
num_blocks = 32 # Up to 256 in theory, but IE5.5 is flaky
for block in range(0,256*num_blocks,256):
fp.write('\n\n
Range %5d-%5d
' % (block,block+256))
start = unichr(block).encode('utf-16')
fp.write('\n
 ')
for col in range(16): fp.write(str(col).ljust(3))
fp.write('
')
for offset in range(0,256,16):
fp.write('\n
')
fp.write('+'+str(offset).rjust(3)+' ')
line = ' '.join([unichr(n+block+offset) for n in range(16)])
fp.write(line.encode('UTF-8'))
fp.write('
')
fp.write(foot)
fp.close()
Exactly what you see when looking at the generated HTML page depends on just what Web browser and OS platform the page is viewed on—as well as on installed fonts and other factors. Generally, any character that cannot be rendered on the current browser will appear as some sort of square, dot, or question mark. Anything that is rendered is generally accurate. Once a character is visually identified, further information can be generated with the unicodedata module:
>>> import unicodedata
>>> unicodedata.name(unichr(1488))
'HEBREW LETTER ALEF'
>>> unicodedata.category(unichr(1488))
'Lo'
>>> unicodedata.bidirectional(unichr(1488))
'R'
A variant here would be to include the information provided by unicodedata within a generated HTML chart, although such a listing would be far more verbose than the example above.
|


The TMWriteAddFile API adds to an opened 'add' file specified by the file handle 'file_handle'. The ‘file_handle’ can be acquired with TMCreateFile for a new file or TMOpenFile for an existing ‘add’ file. An ‘add’ file is a file with extension 100 (decimal) that resides on an EPROM 1-Wire device. The ‘add’ file is special because the contents of the file can be added to without deleting and then rewriting it. The TMWriteAddFile API call has two modes of operation. It can append data to the end of the 'add' file or it can add data at an offset from the beginning of the file. The 'operation' flag is:
1 : Append to the file starting after the last programmed byte (not FF Hex) in the last page of the file.
0 : Write the data starting at the specified 'offset'. If there is data already there then the result will be to program any zeroes in the data. For instance:
00110101 current byte in device
01010111 data byte to program
-------------
00010101 result
Note that with this feature, individual bits can be programmed.
If the operation is 1 'append' then the 'offset' entry is not used. The data is provided in the 'write_buffer' and the length of the data to write is 'num_write' bytes.
For a description of the above types, see the TMEX Type Descriptions.
Parameters
session_handle
Specifies the session handle returned from the API function TMExtendedStartSession that specifies the desired 1-Wire network port. This parameter is required by most TMEX API functions.
state_buffer
Specifies a pointer to a memory location that TMEX keeps all of the state information for the 1-Wire networks. This parameter is required by most TMEX API functions.
file_handle
Specifies a file handle of the file to write.
operation
Specifies the operation mode of appending to the end of the file (1) or writing at an offset (0).
offset
Specifies the offset number of bytes from the beginning of the file if operation is 0 for offset mode.
write_buffer
Specifies a pointer to a buffer that contains the data to write to the file. It must be at least ‘num_write’ bytes long.
num_write
Specifies the number of bytes to write from the ‘write_buffer’.
Return Value
>= 0 => file written, and this is the number of bytesSee Also


Having dealt with a little conflict in my life, I can say it doesn't necessarily take two people to create one. This is the absolute antithesis of the post I had here previously, which I didn't even finish reading before I decided to re-write it.
In my experience today even, internal conflict can take a heavy toll on one's ability to think clearly, and otherwise behave outside the way they prefer to conduct themselves. It wasn't even anything like, terrible that happened today, just something that has happened enough times in front of me that its definitely a thing(that people do). Which is become irritated to strangers in times of unexpected hardship or stress. Particularly, when the stranger is behind a cash register, on the other side of a little protective shieldy window with a metal drawer.


Shahmukhi is a modified Perso-Arab script for the Punjabi language. This keyboard intends to include support for characters, not supported by the Urdu phonetics keyboard such as ArNoon (ݨ) and ArLaam (ࣇ - 08C7 in Unicode), (ਣ and ਲ਼ in Gurmukhi, respectively). ArLaam was added to Unicode recently and proper positioning may not work in all applications. The Scheherazade New font supports the ArLaam and is included in this keyboard package.