Common Lisp homepage - t-sin http://lisp-lang.org <comment><USER2> This is a very nice web site describing a programming language with unparalleled expressiveness, power and permanence.

I am heavily invested in Common Lisp. We are developing a programming environment for designing new materials and molecules called Cando ([https://github.com/drmeister/cando](https://github.com/drmeister/cando)) using Common Lisp as a scripting language. Cando is running on Clasp ([https://github.com/clasp-developers/clasp](https://github.com/clasp- developers/clasp)), a new Common Lisp implementation that interoperates with C++ and is based on LLVM.

What attracted me to the language, after 35 years programming in almost everything else, was how organically it lets one write software and how I don't have to worry about it fading like the next programming fad.

<comment><USER3> > how I don't have to worry about it fading like the next programming fad.

I'm not sure I understand this bit. What other programming language has "faded" and how has it "faded"? At least since the more mature age of software, which I'd say started around '95 or so (so 20+ years).

<comment><USER4> Pascal, perl, ASP, every ML, Fortran, Cobol, Eiffel, Modula, all "4GL" languages.

<comment><USER3> If by ASP you mean classic Visual Basic, I'll grant you that. And Pascal.

But ML, Eiffel and Modula were never mainstream.

And Perl, Fortran, Cobol probably still have more programmers out there than Common Lisp has :)

<comment><USER5> And the fewer CL programmers will run circles around P, F, C programmers :-)

<comment><USER6> So, why don't they? ;)

Why is viaweb and ITA trotted out decade after decade? If CL is so awesome why isn't the world filled with awesome stuff implemented in CL?

(To be clear, IMHO it's a huge shame that more powerful languages like CL or Haskell aren't more popular)

<comment><USER7> Because they won't put in the effort to just pull up and post the customer lists of companies selling LISP commercially. ;)

[http://www.lispworks.com/success- stories/index.html](http://www.lispworks.com/success-stories/index.html)

[https://franz.com/success/](https://franz.com/success/)

The companies that use LISP don't talk about it much. I'm not saying secret weapon or anything either. I'm saying they seem to be among the set that just identifies something good for the business, buys/builds it, and solves business problems. They don't write articles about their programming language. What I will say is the small number of case studies on those two companies have _much more interesting_ software than what's advertised for many stacks. The kinds of things people use it for corroborates the LISP advocates' claim it's a favorite for hardest, constantly-changing problems. It's more remarkable with Allegro since they charge royalties on top of the licensing with customers still buying their stuff.

<comment><USER8> Interesting points.

>It's more remarkable with Allegro since they charge royalties on top of the licensing with customers still buying their stuff.

Do you mean that (apart from the licensing) they also charge a percentage of the revenue or profits that their customers make from products they develop using Allegro's products?

<comment><USER7> It looks a bit different than the last description i saw. Here's current offering:

[https://franz.com/products/licensing/commercial.lhtml](https://franz.com/products/licensing/commercial.lhtml)

They aint cheap or simple with the licensing. People still are buying it, though.

<comment><USER8> Good info, thanks.

</comment></comment></comment></comment></comment></comment></comment></comment></comment></comment><comment><USER9> Lisp is quite popular at my current workplace. A few popular open source projects published by our organization have been written in Clojure (a dialect of Lisp that runs on JVM and CLR). A few domain specific languages used internally in our organization are also inspired by Lisp.

On a more personal front, I find Lisp to be simple, elegant, and expressive. I use Common Lisp (SBCL) for personal use. Working with Lisp induces a sense of wonder: how simple concepts can be composed elegantly to build complex functions and complex software. It's the same kind of sense of wonder one feels when one learns how the simple concepts of Euclid's postulates can be used to prove complex concepts in Geometry or how the Newton's laws of motion can be used to derive intricate and complex concepts in classical physics.

I sometimes wonder why Lisp has not been more popular in the technology industry. Is it the lack of sufficient marketing? Is it the lack of an extensive library ecosystem? I hope Quicklisp will address the concern about library ecosystem for Common Lisp.

I encourage everyone to learn Lisp and, if feasible, write a rudimentary interpreter or compiler for Lisp s-expressions. It's one of those things that can broaden's one horizon in the field of computing.

<comment><USER10> I'd say several reasons: 1.) a lot of folks have trouble with the abstactness 2.) a lot of folks think C syntax is how all languages should be 3.) the lisp ecosystem is fractured into too many lisps like SBCL, Clojure, Racket, Allegro, Franz, Picolisp, ABCL, Shen...etc, so some confusion amongst those that are new 4.) poor windows support for SBCL...it literally tells you it is experimental if I recall correctly. Setup wasn't straightforward 5.) tooling is complex and emacs is recommended for both SBCL & Clojure, which is arguably more difficult than hitting run in most modern IDEs 6.) multi-core seems to only be in Clojure 7.) lack of decent libraries. There is always someone quick to say that this is false and that they have everything you need, but coming from Python and Perl's CPAN, I couldn't disagree more 8.) learning resources are very hit or miss. I found it hard to pay attention to many of the top lisp books because a lot of the examples such as building an mp3 database would be one line of code or two in python. Of course they're just trying to show concepts and terse expressions isn't where lisp shines, but the effect is underwhelming. 9.) your fellow developers won't use it and a large company will probably have an IT department that won't let you run in production without it being far better known: Java, C#, Python, R, C++, Perl, Ruby, JavaScript...etc without major pushback...notice how many people equate lisp with personal projects?

<comment><USER11> 6 - what about [https://common-lisp.net/project/bordeaux- threads/](https://common-lisp.net/project/bordeaux-threads/)

<comment><USER12> ... or STMX, which provides software transactional memory on Common Lisp in an ultra-easy-to-use way.

<comment><USER10> I'll definitely take a look at that, thank you!

</comment></comment></comment></comment></comment><comment><USER13> I highly recommend Eitaro Fukamachi's caveman2 for _very_ quickly setting up a very fast lisp web server including very easy to configure ssl. Fukamachi's Dexador library is also fantastic for very quick and easy ssl http functionality. [https://github.com/fukamachi/caveman](https://github.com/fukamachi/caveman) [https://github.com/fukamachi/dexador](https://github.com/fukamachi/dexador)

</comment><comment> pure-awesome What exactly is meant by the line "Design patterns disappear as you adapt the language to your problem domain."

The word "disappear" is a hyperlink to a pdf, which refers to domain-specific design-patterns. I don't quite seem to grasp what is being implied on the home-page.

Is it something like Lisp is very customizable and allows you to easily overload operators? (I am primarily a Java programmer and have never used Lisp).

 _EDIT:_ I mean, e.g. this page asks "Are Design Patterns Missing Language Features" [http://wiki.c2.com/?AreDesignPatternsMissingLanguageFeatures](http://wiki.c2.com/?AreDesignPatternsMissingLanguageFeatures)

Is this what's being referred to, and if so, what makes Lisp especially good for adding language features?

<comment><USER14> Indeed Lisps claim to fame is how much the language itself is extensible. Something along the lines of "you rewrite the language / expand it" for whatever project you're working on. Writing your own lisp interpreter is another popular type of project people do as well given how simple Lisps syntax is to parse and follow.

If you are interested in Lisp on the JVM check out Clojure.

<comment><USER15> For Lisp on the JVM there is also ABCL, which is a full implementation of Common Lisp: [https://abcl.org](https://abcl.org)

</comment></comment></comment><comment><USER16> What's with the full-page splash that just says "Common Lisp" with no indication that you need to scroll to get to the content. This is worse than the 1990's "Click here to enter the site" silliness.

<comment><USER17> I think this trend really took off with Medium, which encourages large (and useless) banner images at the top of articles. It's an unfortunate trend. It probably also increases bounce rate if I had to guess.

</comment></comment><comment><USER18> If you fancy giving Lisp a try, look into Portacle [0]. I've not used this exactly but I did install all the components myself over time and they play together nicely.

[0]: [https://portacle.github.io/](https://portacle.github.io/)

</comment><comment><USER19> Nice web site! I have been using Common Lisp since 1983 when I updated my Xerox 1108 Lisp Nachine.

In the last 35 years I have probably only averaged using Commin Lisp for about 10% of my development but still love the language.

One problem the Lisp world has is too many fine implementations of dialects of different Lisp languages. I find it impossible to not experiment with most of them.

<comment><USER20> What insights do you gain by experimenting with different implementations of Common Lisp? Can you share some of those insights or things you learnt by experimenting with different implementations of Common Lisp?

<comment><USER19> I don't have much to say about different versions of Common Lisp. I have mostly been using SBCL for years, except sometime switching to Clozure for faster compilation.

I experiment more with different versions of Scheme: Gambit, Chez, and Guile. I really like the Racket ecosystem - a lot of good work is done around Racket. I don;t much use Clozure (except for my hobby site cookingspace.com) unless I am using it because that is what a customer uses.

Church, for Probabilistic programming is interesting but it was apparently been supplanted by WebPPL(which is not a Lisp).

</comment></comment></comment><comment><USER21> Any advantage to learning Lisp instead of something like Elixir today? I find Elixir to be modern, a large amount of libraries, larger and active community, BEAM VM, has macros also... Can`t think of a reason to invest time in Lisp at the cost of mastering something Elixir, but maybe I am wrong.

<comment><USER22> I'm in the same boat as you.

<comment><USER23> You can have your cake and eat it too

[http://joxa.org/](http://joxa.org/)

[http://lfe.io/](http://lfe.io/)

</comment></comment></comment><comment><USER9> Often those who are curious to try Lisp are faced with a number of choices: Which dialect to choose? Which implementation to choose? Which book or tutorial should one follow? Is it necessary use Emacs? SLIME?

Here are my recommendations:

\- Choose Common Lisp because it has been the most popular dialect of Lisp in the overall history of Lisp. It is more convenient than Scheme if one decides to develop serious software in Lisp. Clojure appears to be more popular in the technology industry than Common Lisp among organizations (my workplace included) that use Lisp. I still recommend Common Lisp because I believe that it is more likely that one would work on an independent open source or hobby Lisp project than one would encounter one of the rare organizations who use Clojure at work.

\- Choose SBCL (Steel Bank Common Lisp) as the implementation.[1][2] It is the most popular Common Lisp implementation and is recommended in many online discussions. CCL (Clozure CL, not to be confused with Clojure which is a separate dialect) is also another very good implementation. I still recommend SBCL because as a result of its greater popularity, it is readily available via package managers such as brew and apt-get as well IDE packages such as Portacle, Lisp in a Box, etc. CCL is currently missing from both brew and apt- get.

\- Work through this book: Practical Common Lisp: [http://www.gigamonkeys.com/book/](http://www.gigamonkeys.com/book/) (available in print too if you search online). Skip the sections about Emacs and SLIME if you don't use Emacs.

\- There is no need to use Emacs if you are not an Emacs user. Any good editor would do.

\- A Vim user may consider installing Slimv[3][4]. Superior Lisp Interaction Mode for Vim ("SLIME for Vim") or Slimv is similar to Emacs/SLIME, displays the REPL in a Vim buffer, and comes with Paredit mode that makes typing and executing Lisp code quite convenient.

\- Emacs with SLIME or Vim with Slimv are quite useful but not necessary. To get started quickly without being bogged down by the details of an editor, just execute the Lisp source code file on shell.[5]

\- Optionally, keep another implementation of Common Lisp. Common Lisp is a standard that is implemented by various implementations. Each implementation may have its own extensions or implementation-specific behaviour regarding error handling, command line options, FASL format, unspecified behaviour, etc. Experimenting with concepts with another implementation of Lisp occasionally may offer some perspective about how some things could be different in different implementations. I keep CLISP around for this purpose.[6][7][8]

[1]: Install SBCL on macOS: brew install sbcl

[2]: Install SBCL on Debian-based distro: apt-get install sbcl

[3]: Slimv in a ZIP file: [https://www.vim.org/scripts/script.php?script_id=2531](https://www.vim.org/scripts/script.php?script_id=2531)

[4]: Slimv as a Git repo: [https://github.com/kovisoft/slimv/](https://github.com/kovisoft/slimv/)

[5]: Load (execute) code in a file and exit: sbcl --script foo.lisp

[6]: Install CLISP on macOS: brew install clisp

[7]: Install CLISP on Debian-based distro: apt-get install clisp

[8]: Unfortunately CLISP is missing from Debian's _stretch_ (stable) repository but it is available in its _buster_ (testing) and _sid_ (unstable) repositories. Hopefully this will be addressed when _buster_ becomes stable. CLISP is available on Ubuntu.

<comment><USER24> What confused me a lot is that nobody seems to give an example on how to build a binary out of a Lisp program/make it runnable from command-line.

Also most tutorials/books I found don't guide you on how to build an application/structure your code – which is rather confusing for a beginner. You have to spend a lot of time and try and error to get things working using Quicklisp. I got often the impression, that since Lisp is so old, everyone using it knows how to do things and forgot to document for newcomers their knowledge.

<comment><USER25> The reason nobody can give you an example for how to make a binary is because there are many many different ways of doing that. To name just a few:

* in ABCL you would generate a jar file, just like with java or clojure

* in SBCL you could dump a core file, there are some tools that can package that up in a command line binary

* if you use a bytecode compiler(like clisp), you'd use that the same way like python or ruby, you'd put your script in a text file, with a #! line at the top and run it like any other shell script.

* if you use a Lisp->C compiler, you'd generate C code and then compile that with GCC or Visual Studio or whatever

* if you use image based programming, you'd just load your code in the lisp image and just use lisp itself as your command line, your "binary" would then be just a normal lisp function.

* If you're deploying a service, you might want to package it in a docker image or even a VM image or have some build and deploy script depending on your environment or needs.

I'm probably missing some, but that's the basics.

</comment></comment></comment><comment><USER26> The giant header that fills the first page, forcing a scroll into content, is right up there with unskippable flash intro videos from 10 years ago.

<comment><USER14> I'm not sure why this is even a thing, even on news articles with huge images, it's just POINTLESS to me. "Oh I guess you don't want me to read this article" _click_

</comment></comment><comment><USER27> I know the article is about Common Lisp, but I have a question about Racket, Typed Racket specifically. Can anyone say if types and Lisp play well together? Are there any success stories?

<comment><USER28> Types are supported since the 80ies, with (the) and optional declarations. Almost nobody uses them. Well, CL says: types are always carried around in every value, so we do have types, and we are always type-safe. Which is a proper point.

Then SBCL has superior internal type support in its python compiler, leading to many optimizations. It creates specialized copies of typed methods, and has a nice optimizer framework to deal with that.

Felleisen (Typed Racket) seems to hate types, he summarizes it with types make racket slower, not faster. But he is still developing the only seriously typed scheme effort. Forgot about Stalin, but if I remember correctly it was similar to the CMUCL/python type optimizer.

In my dynamic language I've implemented gradual typing with great success (cperl): more precise, producing better specialized code, faster, detecting more errors at compile-time and better documentation, so I'm sceptical why Felleisen has so many problems. But I implemented it with performance in mind (premature optimization and such), not completeness. Typed php seems also to go well, also the various JavaScript variants. Just scheme, python and ruby not so.

<comment><USER29> In my experience Typed Racket programs are never slower than their dynamically typed Racket equivalents. Sometimes they are faster (such as when the program does a lot of numeric computation).

What _can_ be slower is a _mix_ of TR and R. Because TR protects the boundary between the two with runtime contracts. Because it wants safety/soundness.

I'm not any kind of gradual typing expert, but, it seems like you could calibrate speed vs. soundness for boundaries in different ways. TR has prioritized soundness but it seems like you prefer speed.

<comment><USER28> Well, I do have the same problems between unchecked and checked expressions. You get the speed only with series of checked expressions, but you have to cast to any/dynamic/cons boxed type on each boundary. This is the major slowdown. When the series of expressions is too short, no transformation to native should be done, because the casting and conversion back and forth is more expensive than the win by using the specialized ops.

Similarily SBCL/CMUCL has the similar problem with polymorphic explosion of generating too many methods, which are rarely used. Javascript V8 and friends solved that better.

My speed comes from avoiding consing, my native types are bitfields. Lisp types are usually a class pointer for every cons cell. For me certain casts are permitted, which are not permitted with Typed Racket. So yes, I have to permit traditional code which worked before, esp. with inferred types from literals. Racket has the advantage of defining stricter language subsets, which we only have with Perl 6 also. There you can override even language and type semantics.

Chez has a nice tagging scheme, which should speed up Racket a lot.

Several gradually typed languages don't infer from literals, but that's one of the best speed gains. E.g. the literal 1000 is a union of int32, int64, uint32 and uint64, all possible valid integer types for a certain value. A negative number cannot be unsigned, and a too large number cannot be 32bit. Problem is that people rarely add types, you need to infer 90% of them.

</comment></comment></comment></comment><comment><USER30> Great site, seems to have a good collection of lisp resources. I am waiting for the documentation to go online, it says it is still parsing the TeX sources of the commonlisp hyperspec.

As a side note, I downloaded the Lispworks Common Lisp Hyperspec, but I could only find the HTML version.

I see that the project is on Github, maybe someone will parse the Hyperspec and generate the documentation pages.

I am adding a reminder to my org-agenda for next month, maybe I will attempt to do it :).

<comment><USER31> It looks like the Hyperspec license doesn't permit distributing documentation pages:

> Permission to make partial copies is expressly NOT granted, EXCEPT that > limited permission is granted to transmit and display a partial copy the > Common Lisp HyperSpec for the ordinary purpose of direct viewing by a human > being in the usual manner that hypertext browsers permit the viewing of such > a complete document, provided that no recopying, redistribution, redisplay, > or retransmission is made of any such partial copy.

Source: [http://www.lispworks.com/documentation/HyperSpec/Front/Help....](http://www.lispworks.com/documentation/HyperSpec/Front/Help.htm)

But I guess you could distribute a script that does the processing.

<comment><USER32> Reading the whole thing it seems you're allowed to distribute it as is without changing anything, and not getting any commercial advantage out of the distribution.

There's this: [https://github.com/LispLang/ansi- spec](https://github.com/LispLang/ansi-spec)

Working from the TeX sources seem to be the right way to go especially if the information can get extracted into a generic representation so there could be a HTML / epub / whatever version

</comment></comment></comment><comment><USER33> This is _not good_ , the info density for the screen area is too low. This could have been one maybe two screens worth. Is this the credits to Friends? Am I consuming Lisp Content while chillin in my penthouse on my 20k couch using a gold plated IPad X Tablet?

Millennials are Killing Common Lisp.

one page, [https://www.rust-lang.org/en-US/](https://www.rust-lang.org/en-US/)

<comment><USER14> The Racket-Lang site almost had it perfect:

[http://racket-lang.org/](http://racket-lang.org/)

The stuff above the language description should be shoved to the bottom (excluding obviously the top menu) and it would be perfect. I miss their old site because it was obvious and to the point and had examples right away.

<comment><USER34> Huh? If I exclude completely uninteresting "Racket School 2018" announcement, I have 18 words (plus some pointless images) on the first screen.

Oh, apparently I'm supposed to hover over the images to see more text. Why?!

<comment><USER14> I mean exclude those too and the page looks much better.

</comment></comment></comment></comment><comment><USER8> Is there any official (other than any ANSI standard site) or quasi-official or unofficial main site for Lisp or Common Lisp?

I had seen a couple of other sites which _seemed_ like they might be that earlier, like [https://common-lisp.net/](https://common-lisp.net/) and the site of the Association of Lisp Users, which I vaguely remember as being at [http://alu.org](http://alu.org) , but now a Google search shows some other sites instead (from the first few hits I looked at). And now there is this one mentioned in the OP. I looked at its About page, [http://lisp- lang.org/about/](http://lisp-lang.org/about/) , but it does not seem to show any such info.

Update: I saw this on the common-lisp.net site:

"This site is one among many gateways to Common Lisp."

which seems to indicate that there was/is no single "(un)official" one.

<comment><USER25> Where is C's (un)official home page?

</comment></comment><comment><USER15> For those who want to use Lisp on the JVM, there is ABCL:

[https://abcl.org](https://abcl.org)

ABCL was originally used to write and extend an editor called J - but then morphed into a full implementation of Common Lisp.

One can also develop with SBCL - since it has a great compiler - and then move the code to ABCL.

<comment><USER35> There's also clojure on the JVM.

<comment><USER15> Note though that Clojure is not compatible with Common Lisp, thus the information from the 'Common Lisp homepage' linked here is not applicable.

</comment></comment></comment><comment><USER36> At the request of John McCarthy, Lisp's creator, no single language that is a member of the Lisp family is to be intended to be the definitive dialect; that is, none is to be called just "LISP."

So much innovation has happened since the CLHS that to put up a fluff site feels like an effort of "resurrection". When in reality the Lisp family has continued to evolve since then. To limit yourself to just CL, as I did, for a long time, results a bit of a 'losing my religion'. You'll be confounded by things long since solved, and in the end perhaps write all of "Lisp" off. Do yourself a favor and keep and open mind to the family, and not one common incarnation that predates some developers.

<comment><USER2> "Fluff" "FLUFF"??? If that's fluff then most of the rest of the web is fluff... oh wait.

Seriously, the web site is a very informative site about "Common Lisp" \- a specific dialect of Lisp. It's right there when you click the link, big letters - "Common Lisp" \- you can't miss it.

You could argue about the URL "lisp-lang.org" \- but why?

<comment><USER37> "We are in the process of decoding the original format used for the CLHS." This is a smell that highlights the above post it seems.

<comment><USER2> It's more of an issue at the interface of technology and licensing. The CLHS (Common Lisp Hyper Specification) is a very large, web based document written in the 80's and it looks like an old Geocities web site. I believe the CLHS license says that it's not allowed to be changed (to protect the standard - <AUTHOR> believe - someone correct me please) and so the community is working from slightly older drafts and figuring out how to automate the conversion to something that looks more modern. It's not a problem with Common Lisp - it's a problem that HTML, the web and user expectations have been changing over the years. There's that permanence thing again.

<comment><USER15> > is working from slightly older drafts

Not really, the content is the same.

</comment></comment></comment></comment></comment><comment><USER38> Is main page created with Powerpoint? /learn/ is good (better than nothing or than ancient PDFs) but no real documentation yet.

</comment><comment><USER10> [http://lisp-lang.org/success/](http://lisp-lang.org/success/)

</comment><comment><USER39> Is there a way to find well-maintained non-broken preferably-actively- maintained libraries or those that the community considers to be the de facto solution? Like where would I start with doing data science or web dev (and related subjects like encryption and auth etc) or things like async or parallel programming?

</comment><comment><USER40> Why the "Fast" section (or graphs on [https://github.com/fukamachi/woo](https://github.com/fukamachi/woo)) don't contain any JVM based solutions? Anyone has idea how do they compare?

</comment><comment><USER41> My AI class teacher was one of the founders of Siscog. I learned scheme and lisp at college too. Glad to see his company being mentioned.

<comment><USER42> You might be pleased or displeased to know that at Técnico they no longer teach Scheme in the introductory programming course, nowadays it's Python. When I did the AI course, the project was still to be developed in Lisp, but more recently I recall hearing that they were thinking of switching to another language because "nobody can stand lisp". Fun fact: one of the founders of Siscog, Ernesto Morgado[1], is big in the rice business, and is/was the president of multiple rice millers associations. Both Pavão Martins and Ernesto Morgado still lecture at Técnico.

[1] [https://en.wikipedia.org/wiki/Ernesto_Morgado](https://en.wikipedia.org/wiki/Ernesto_Morgado)

<comment><USER41> In hindsight, displeased for sure.

</comment></comment></comment><comment><USER43> Great to see a pretty Lisp site up. Loving it.

</comment><comment><USER44> Nice site!

I bought cdr.io years ago when I was seriously into Lisp. If anyone has an idea for it, happy to pass it along.

</comment><comment><USER45> Any good implementations if common lisp on Windows?

<comment><USER46> Clozure CL ([https://ccl.clozure.com/](https://ccl.clozure.com/)) is the counterpart to SBCL on Windows. I never had much luck with SBCL on Windows (granted, I haven't tried in about two years) but Clozure CL always worked fantastically (including threading, FFI, etc).

</comment></comment><comment><USER47> (mapcar #'string-downcase (list "Hello" "world!"))

This is a great example of why I don't want to use Common Lisp.

Compare with Python:

[word.lower() for word in ("Hello", "world!")]

Beating Node and Ruby in terms of speed is also a big non-argument, with so many attractive programming languages to choose from that are both fast and good looking.

<comment><USER48> Can you elaborate on why?

I know both Python and Common Lisp, neither version looks any better than the other to me.

Also, as another commenter notes, the snippets are not actually good translations of each other. Your CL snippet would look like this in Python:

        list(map(str.tolower, ("Hello", "world!")))

While your Python snippet would look like this in CL (as pavelludiq notes):

        (loop for word in '("Hello" "world!") collect (string-downcase word))

Granted, Lisps tend to be a bit more verbose (longer names, less symbols used), which is a natural consequence of having little syntax. It has serious advantages when learning the language or when reading unfamiliar code, although it comes with some drawbacks, too.

<comment><USER49> Actually, lisp varian can be also a:

        (mapcar #'string-downcase '("Hello" "world!"))</comment></comment></comment>


Microsoft warns of possible attacks after Xbox certificate leaked - <AUTHOR> http://www.zdnet.com/article/microsoft-warns-attacks-possible-after-xbox-certificate-leaked/ <comment><AUTHOR> actually sorry about this. Dupe. Previous discussion at [https://news.ycombinator.com/item?id=10699281](https://news.ycombinator.com/item?id=10699281)</comment>


Ask HN: Review my wish list side project, WishBooklet - <AUTHOR>

Hello fellow HNers,
The holidays are coming and I thought I'd demonstrated my wish list website as it seems appropriate. Initially, this project started as an entry into a local web app competition(which I did not win). Since then, I've been working on this "side project" on my spare time. I designed it and programmed by myself. For the most part it's functional, except the "crowdfunding" functionality needs some work to fully work as I envisioned it. I am aware Amazon has a similar service, but I don't think they have crowdfunding?
The URL for my websites is http://www.wishbooklet.com/ For invite code you guys can use: pandora
Once you sign up you, I have a bookmarklet at http://www.wishbooklet.com/wish-it-button (still needs work, doesn't look that good, etc.)
I hope to hear your thoughts on it. :)
Thank you!
P.S. I'm looking to possibly moving to the Bay Area next month, if you know anyone hiring let me know, my email is in my profile. :) <comment><USER2> It would seem difficult to get people to crowdfund gifts or know to in general for gifting no? Have you had any successful usage for that feature?

<comment><USER3> Crowd funding gifts... hmmm - tough case, I'd think. I can think of one case - when my nephew turned 10 years old, he asked for $20 cash instead of gifts. He wanted to save up enough for an iPad which was $500. He invited 22 other kids to his party, each of whom brought $20. When he combined that with the other money he'd saved, he was able to buy it.

The question is would the 22 other nine and ten year old boys have "crowd funded"? No, not a chance!

</comment></comment><comment><AUTHOR> Clickable: <http://www.wishbooklet.com/></comment>


How to Adopt Modern C++17 into Your C++ Code [video] - <AUTHOR> https://www.youtube.com/watch?v=UsrHQAzSXkA <comment><USER2> C++17 is definitely going in the right direction for most applications. But I have the feeling, that the compiler implementations cannot catch up with the modernization speed.

We are using C++ for embedded devices and recognize a steady code bloat with every release since C++11 (especially with C++17) without using any of the new features (with gcc/clang). This is a trust-killer and actually the reason we stay on C++11 for embedded development.

<comment><USER3> Just curious: why did you choose C++ instead of C for embedded? Most shops I know chose C just because of code bloat.

<comment><USER2> I have to admit, that C++ is still not the industry "Go-To" language for embedded. But if you apply modern C++ correctly, there is very few overhead compared to C and the software is much easier to maintain.

The performance of embedded MCU's are continuously rising over the years and that little overhead is buying development speed.

Not to mention smart pointers, templates and constexpr making my life easier.

The only real issue with C++ is, that as soon as you get into serious embedded applications, you have restrictions when it comes to heap usage e.g. in medical devices using the heap is forbidden. So you cant use the STL.

There is a promising embedded STL project, but it's not there yet: [https://www.etlcpp.com](https://www.etlcpp.com)

<comment> Const-me > So you cant use the STL.

std::array is in there since C++ 11 and it doesn't use heap.

And/or you can use STL with custom allocators that work without heap. We did something similar developing for Nintendo Wii console. There was a heap but we didn't want to use it to avoid memory fragmentation. AFAIR we used two arenas (essentially stacks), one very small for temporary data cleaned up at the start of each frame, and a large one cleaned up when a level is unloaded.

However, I don't have hands on experience developing firmware for medical devices, so I'm not sure it'll work for them.

<comment><USER4> The problem for medical devices isn't so much whether custom allocators will _work_. The problem is whether the FDA will freak out because you're not following industry-best-practice coding guidelines.

<comment><USER5> That's really not how it works. The FDA is fundamentally concerned about two things, safety and efficacy. You need a plan to demonstrate the latter, and you need your quality system, SDP, etc. to demonstrate how you approach the former. This is about good engineering practices, not particular implementation techniques.

So you can do things many different ways. If you do say "we do this like X, which is industry standard, just like T, U, and V do" it's a simpler argument than "we do this like Y. Lots of people do X, but here is how we have demonstrated Y is better for us...". But this can be fine too, just possibly more work.

Also worth noting (a) there is no industry-wide best practices agreement (b) there is no FDA wide agreement on what should be done (different device types are reviewed by different panels (c) the FDA doesn't understand software development deeply across it's panels, but it is catching up.

<comment><USER4> Sure, that's all true. I'm looking at the "simpler argument" part.

It's especially true if you're saying "This new device is just like our previous device, with these few small changes". (I forget what that's called, but you can do a lot less paperwork if that's true.) But if you start doing memory allocations where you never did before, they're probably going to want to apply higher scrutiny to your entire software. That's... painful.

<comment><USER5> You are possibly thinking about note-to-file (which isn't quite the process any more, but similar)

But it is worth pointing out, FDA (or other national body) isn't doing code reviews. They are mostly interested in process , and how you follow it. The place where this really interacts s is hazard analysis, and then it's just up to you to demonstrate your checks and balances.

</comment></comment></comment></comment></comment></comment></comment></comment><comment><USER6> ::Somewhat tangential anecdote and plea for advice::

I just finished my third semester of using C++ (with Data structures 1) and we use _NO_ modern stuff in class [1]. Raw pointers. New and delete. No Lambdas (although we learned about function pointers, though not function objects). I completely understand _why_ (we're learning low level stuff and it's worked for the last 30 years so whatever), but now I'm trying to ramp up and learn modern C++ for a personal project I'd like to start working on (basically an audio plugin using JUCE).

Here's what I've been doing to try and catch up (I have two weeks off before my internship starts). I try to watch Bjarne and Herb's keynotes but they often are speaking to an audience already familiar to modern C++, so this posts video is great! I've discovered the brilliance of Sean Parent, so I'm watching all of his talks. I've ordered Scott Meyers _Effective Modern C++_ (and hopefully he uses the money for a new haircut /s). I've browsed through the C++ Core Guidelines [2]. I'm reading the JUCE tutorials (and source code) which is beautifully written.

What are other good resources? I'm particularly interested in developing GUI's. I'd like to see some tutorials written like Herbs talk here: for people new to C++ _and_ new to modern C++.

[1] This is our textbook: [https://www.amazon.com/Programming-Program-Design- Including-...](https://www.amazon.com/Programming-Program-Design-Including- Structures/dp/1285852753)

[2] [http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#...](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#S-introduction)

<comment><USER7> Effective Modern C++ is a great book designed for "I learned pre C++11, but now I want to get with the times, and specifically want to know the idiomatic ways to apply it".

<comment><USER8> Is Effective Modern C++ good enough for those who learned C++ in the early 2000, still use those idioms and never upgraded to C++11 ?

<comment><USER9> I'd recommend Bancila's Modern C++ Cookbook instead, it takes you through the new features and explains how to use them.

Effective Modern C++ is part language tutorial, part series of tips, part philosophical discussion on how one should use various features. It's not appropriate as an intro to modern C++.

<comment><USER7> > Effective Modern C++ is part language tutorial, part series of tips, part > philosophical discussion on how one should use various features. It's not > appropriate as an intro to modern C++.

See, I take the opposite stance. There's enough moving parts here that it's nice to get some background into what's actually happening, and then read more cookbook style stuff when you understand the underlying context.

</comment></comment></comment></comment></comment><comment><USER10> Great talk, but I still have a couple questions that I'm sure someone here can answer:

1\. I didn't see what the smart pointer stuff had to do with C++17. Aren't these all available from C++11? Are these something new that I missed, or are they just comments on how to avoid bugs, based on Herb Sutter's personal experience?

2\. Should I std::string_view everywhere I used to use std::string now? The examples given seemed to lean heavily towards using std::string_view as parameters instead of std::string, but should I use them as a drop-in replacement everywhere?

3\. The std::optional example looked really clunky, relying on checking an exception. I see there are a bunch of nice operators and utility functions on std::optional that cover some use cases, like coalescing, but will we get something that allows for optional chaining?

<comment><USER11> > 3\. The std::optional example looked really clunky, relying on checking an > exception. I see there are a bunch of nice operators and utility functions > on std::optional that cover some use cases, like coalescing, but will we get > something that allows for optional chaining?

Nope. It must be understood that std::optional is not an Option type, its purpose is not to have a way to express "missing" items _in a type-safe manner_ but rather to have pointer-type semantics without needing to heap- allocate. So you can just deref' an std::optional, and it's UB if they're empty. Don't think of it as Haskell's Maybe, think of it as a stack-allocated version of std::unique_ptr.

<comment><USER12> > ...its purpose is not to have a way to express "missing" items in a type- > safe manner...

Except that's exactly why you would take an `optional<int>` as a parameter. To avoid the ambiguity and possible bugs of taking an `int*`.

<comment><USER11> > Except that's exactly why you would take an `optional<int>` as a parameter.

Except for the type-safe part which is the important bit (hence the _emphasis_ on it), and which std::optional does not provide.

> To avoid the ambiguity and possible bugs of taking an `int*`.

The only ambiguity and possible bug (singular) you're avoiding using std::optional is the question of ownership. Because as emphasised in the original comment std::optional is no more type-safe than a raw pointer.

<comment><USER12> Clarity about ownership is enough. But there's also ambiguity because pointers are sometimes used to pass around arrays, especially in the case of 'char*'. And a dev also has to go out of his way to create a dangling optional<int>.

Even if we consider just ambiguous ownership, there are a whole host of behaviors that could result from that single design mistake, including undefined behavior, which could include trashing your production database, firing the missiles, or behaving as expected until an unrelated piece of code changes a year later.

</comment></comment></comment></comment></comment><comment><USER13> I just checked how many times I use explicit delete in my moderately sized 7K LOC C++ project: just once. In code that interfaces with an old library. Modern C++ is not only practical. It's easy.

<comment><USER14> You using smart pointers from C++11 or later?

<comment><USER13> Yes. But surprisingly not as often as I thought I would. Move semantics and guaranteed copy elision allows to avoid pointers in many common situations.

<comment><USER15> It's also better in that you can avoid cycle-leaking from your smart pointers.

<comment><USER14> I'm still having trouble seeing how move semantics and copy elision help me get rid of smart pointers. I read up on it after reading these comments and just still am not following. I see how move semantics avoid a copy, but if I'm dealing with cases where multiple objects need to use or hold a reference to the same object, how can move semantics help me do this? Seems good for ensuring only one object contains the reference.

<comment><USER13> Notice that I didn't say all cases. Just the most common ones. When you require shared ownership of an object, of course, you'd use an appropriate smart pointer (shared_ptr). But shared ownership is not very common (well, at least in the systems that I design). However before C++11/14, you had to use pointers and heap allocated objects in cases that have nothing to do with shared ownership because passing objects by value would incur a substantial overhead. Now that we have move, copy elision and library classes like std::optional (which I forgot to mention earlier) it's not the case any more.

<comment><USER14> Ah I'm following now. Transfer of stack references in cases where it's unnecessary to share objects. Actually interesting that it raises the bar for the need to allocate on the stack.

</comment></comment></comment></comment></comment></comment></comment><comment><USER16> I have struggled in the past to learn modern C++. I think the language is pretty cool, but couldn't find good guide in learning about them.

Having used Rust for a year or so, now I look back at these features and they seem quite natural. I have to say the documentations and tutorials from Rust community is great. It might be a detour, but now I feel much more comfortable reading modern C++ blogs and watch this video!

</comment><comment><USER17> I think it would be good to break backwards compatibility and start off clean with what we know now in the form of a new language.

</comment><comment><USER18> Link for those that can't use Youtube: [https://channel9.msdn.com/Events/Build/2018/BRK2146](https://channel9.msdn.com/Events/Build/2018/BRK2146)

(also has download links)

</comment><comment><USER19> Sanity check, does gcc support all of these?

<comment><USER20> Yes, but the final version of the C++17 standard was released as late as December 2017, so support may not be "production ready", neither in gcc nor in other compilers.

You can the summary of the gcc c++ standard support here: [https://gcc.gnu.org/projects/cxx- status.html#cxx17](https://gcc.gnu.org/projects/cxx-status.html#cxx17). Full support for all features in the c++17 standard, but the support is declared "experimental".

Similarly here for clang: [https://clang.llvm.org/cxx_status.html](https://clang.llvm.org/cxx_status.html)

And Visual studio: [https://blogs.msdn.microsoft.com/vcblog/2018/04/26/announcin...](https://blogs.msdn.microsoft.com/vcblog/2018/04/26/announcing- msvc-conforms-to-the-c-standard/) (link to latest blog post, perhaps there is a status page that gets updated, but could not find it).

<comment><USER21> Maybe I'm missing something, but [http://en.cppreference.com/w/cpp/compiler_support](http://en.cppreference.com/w/cpp/compiler_support) seems to have it all in one place.

<comment><AUTHOR> It misses most of the compilers on the embedded space.

For example, TI still has some compilers stuck on C++98 and C++03.

[http://processors.wiki.ti.com/index.php/TI_Compilers_and_Ind...](http://processors.wiki.ti.com/index.php/TI_Compilers_and_Industry_Standards#C.2B.2B_standard)

</comment></comment></comment></comment><comment><USER22> Can I cheaply "pattern match" on variant type without involving exceptions or dynamic cast etc?

<comment><USER23> I think visit is what you want ([http://en.cppreference.com/w/cpp/utility/variant/visit](http://en.cppreference.com/w/cpp/utility/variant/visit)), unless I misunderstand what you mean by "pattern match"

<comment><USER24> I used to keep pretty good track of what's been happening in c++, at least as C++11 was being formalized, and I've read a good fraction of Effective Modern C++, but...

I can't make heads or tails out of half of the code in that example. C++ has become extremely hard to grok.

I mean, take these two lines:

        template<class... Ts> struct overloaded : Ts... { using Ts::operator()...; };
        template<class... Ts> overloaded(Ts...) -> overloaded<Ts...>;

What's even going on there? Inheriting from a variadic list of classes? `using` a variadic list of parent functions, I guess? The second line looks like it's defining a constructor function for the overloaded() struct, but it's not implemented anywhere?

In the end there's magic code that looks like pattern matching, but I have no idea how they got there.

<comment><USER13> > What's even going on there?

The first line defines 'struct overloaded' derived from all of its template parameters. Template parameters are supposed to be functors (lambdas), so we use their operator()'s in 'overloaded'.

The second line defines a template deduction guide for the 'overloaded' constructor, which says: take types from the constructor arguments and use them as the class template parameters.

The idea is to be able to construct 'overloaded' like this:

        overloaded{[](ArgT1 arg){/*lambda1*/},
                   [](ArgT2 arg){/*lambda2*/}, ...};

</comment></comment></comment></comment><comment><USER25> People who are looking for a modern C++ should take a serious look at Rust. It has all the things you want in modern C++ while getting rid of the cruft of the language.

<comment><USER13> I'd love to. But seeing how Rust adopters struggle with something as trivial as a linked list ([https://news.ycombinator.com/item?id=16442743](https://news.ycombinator.com/item?id=16442743)), doesn't inspire me.

<comment><USER26> Linked lists are easy. People are struggling with _safe_ linked lists, because they think they should be as easy to write as an _unsafe_ ones.

But if you're already willing to use C or C++, you've got no reason to avoid unsafe.</comment></comment></comment>


Exclusive Interview: Hacking The iPhone Through SMS  - <AUTHOR> http://www.tomshardware.com/reviews/hacking-iphone-security,2384.html

<comment><USER2> _Charlie: The iPhone bug has to do with telling the phone there is a certain amount of data, and then not sending it as much as you said you would. The function that reads the data starts returning -1 to indicate an error, but the other parts of the program don't check for this error and actually think the -1 is data from the message. This shows how complex it can be to write secure code, as separately, each part of the program looks correct, but the way they interact is dangerous!_

OUCH.

If there's an industry contest I'd like to referee now, it's fuzzers vs. static analysis. Industry spends a cubic shit-ton on static analysis (for instance, find an F-500 that doesn't have a couple copies of Fortify gathering dust). But fuzzers appear to be kicking ass in terms of actual findings, and vendors don't invest nearly as much into them.

(Static analyzers parse and symbolically analyze source code or binaries against rules, like taint propagation and API blacklists; fuzzers mimic actual inputs to real running systems and vary those inputs maliciously over minutes, hours, or days).

<comment><USER3> I continue to find it amazing that people don't routinely fuzz their protocol handlers. It's a test that you can literally write in 10 minutes.

<comment><USER2> Especially if you're the actual developer. 80% of the time it takes to write a third-party fuzzer goes into reconstructing the target's protocol or API from scratch.

</comment></comment></comment><comment><USER4> The SMS handling process runs as root. The protocol is used for all kinds of device <\--> network traffic. Developers have the ability to make these SMS messages look however they want them to. Users have no indication when a malicious SMS is received.

I think we may see some real exploits happen soon.</comment>


Paul Graham's Search for the Next Facebook - <AUTHOR> http://www.businessweek.com/magazine/content/11_10/b4218038672660.htm

<comment><USER2> I love how pg always has this kinda 'child like joy' smirk on his face for these press pictures.

Like he is thinking "this is SOO cool...Mom is gonna be soo proud."

<comment><USER3> I interpreted that look as "You're going to put some really lame headline above me aren't you?"

<comment><USER4> His prescience knows no bounds.

<comment><USER5> I hate to derail, is that ripped from Greg Proops?

If you're going to steal, he's a great source for material :)

</comment></comment></comment></comment><comment><USER6> Rather short and disappointing article given the headline. I took a long sip of my coffee, reclined and looked forward to reading something much longer and better...but alas it wasn't to be!

</comment><comment><USER7> I find it surprising that Heroku was the breakeven point. There have been other (what I consider) rather high-profile exits, such as Cloudkick, Reddit, Etherpad, 280 North, etc. These were good companies and were acquired for significant amounts; it seems like YC would have realized some significant gains on them.

<comment><USER8> The article might have meant YC recouped their past investments in all startups combined:

"YC broke even on its past investments when Salesforce.com (CRM) bought YC company Heroku"

Since the sales price is above 200 million, YC's equity would be worth 12+ million, which likely surpassed the total monetary first-seed investments in every startup they did so far.

<comment><USER2> That is kinda staggering given that there are still many stars that are doing pretty well...that YC is yet to exit. From Dropbox to AirBnB to WePay to Wufoo to Justin.tv to Posterous to Scribd, etc. All of those I suspect, if they have an exit (I doubt Wufoo will - mainly because I don't think the founders are interested), it will be pretty substantial.

</comment></comment></comment><comment><USER9> I believe the title is a bit misleading. Nowhere in the article was the name Facebook mentioned except in title.

<comment><USER10> The people who write the articles are different from the people who write the headlines.

<comment><USER11> And the headline stringers probably think, "I've never heard of pg, so my readers haven't either. I better put 'Apple' or 'Facebook' in this headline." [/cynicism]

</comment></comment></comment><comment><USER12> As someone who is looking to apply, even at this stage, having YCombinator as an option is tremendously invaluable. So on behalf of the dreamers out there, I say thanks Paul, Jessica and crew. Even if not accepted, just having that door there gives one more clarity moving forward by removing lots of the uncertainty.

</comment><comment><USER13> _(Think MTV's Real World, but for geeks.)_

Oh, boy... The idea of some TV executives out there, champing at the bit to create a reality TV show about entrepreneurs is either f!#@ng scary or LOL funny.

I can just see it now... " _Survivor: YC_ " or " _The Entrepreneur: Paul Graham Edition_." Even better: " _Entrepreneur Death Match: Paul Graham v. Steve Case_." And the inevitable " _VC Revenge Stunts, hosted by Sean Parker_."

" _Mark Zuckerberg Goes Back To College_ " might be entertaining though.

<comment><USER14> It exists and is called Dragons' Den.

<comment><USER15> American version is called Shark Tank, and based on the deals the investors offer, it's aptly named.

Mark Cuban has signed on to be part of the next season!

<comment><USER16> Mark Cuban had a TV show, _The Benefactor_ [1], with a similar premise.

[1] <http://en.wikipedia.org/wiki/The_Benefactor>

<comment><USER13> Interesting, I totally missed that somehow. Probably because I don't really watch TV much. Oh well... you win some, you lose some.

</comment></comment></comment></comment></comment><comment><USER17> I think it's inaccurate about the deal with SV Angel and DST, isn't it SV Angel and Yuri Milner as an individual?

As for breakeven, I wonder whether that's accurate, but considering the low percentage of shares YC takes I wouldn't be surprised if lots of successful but not blockbuster spawn could still leave them without huge returns.

<comment><USER18> What does YC take? 5% for $20,000? They're getting a return if it sells for $500,000. Granted there's going to be a lot of dilution 99 times out of 100, but if most acquisitions are in the $10m-$100m range then they can still take the dilution and do pretty damn well with their current batting average.

</comment></comment><comment><USER19> Anyone know what the "bottlenecks" are in YC? I assume it has to do with the number of advisors? Also, I wonder if the growth in number means decrease in quality (or experience) for the entrepreneurs.

<comment><USER20> The biggest bottle neck is quality applicants, if I remember correctly. I believe PG mentioned that Y-Combinator could triple in size and not be severely affected, though.

<comment><USER21> Although that might be the first bottleneck YC probably cannot remove, the bottlenecks PG talks of in the OP (such as office space) are the removable, short-term ones that prevent YC from immediately tripling in size.

</comment></comment></comment><comment><USER22> Great article.

</comment><comment><USER23> Loved this quote from the article: "This is the Harvard, so to speak, of entrepreneurship" Says something about YC.

<comment><USER24> Shouldn't it be the Stanford of entrepreneurship :)

<comment><USER23> Or may be Stanford is YC of CS.</comment></comment></comment>


Crowd sourcing your Spotify playlist live - <AUTHOR> https://populrr.com <comment><USER2> i can no longer tell the difference between side projects and startups

<comment><USER3> That's either a great thing for a side projects, or rough thing for startups.

</comment></comment><comment><USER4> We've been using a similar service for our office:

[https://jukestar.mobi/webapp/#partySearch](https://jukestar.mobi/webapp/#partySearch)

Worked super well.

</comment><comment><USER5> I prefer the similiar one for youtube party, which is free [http://www.youparty.in](http://www.youparty.in)

</comment><comment><USER6> I was working on this exactly two weeks ago. Nice Job guys. [https://github.com/shashanksurya/YoCoolSpotify](https://github.com/shashanksurya/YoCoolSpotify)

</comment><comment><USER7> This could make for some interesting social experiments. I'd be interested in seeing data that shows how people react to this and use it.

</comment><comment><USER8> How about starting some party and sending name here? I would like to join, maybe just for sake of testing. ;-)

</comment><comment><USER9> Looks neat. You might monitize it by selling to some cafes(only whitelisted music allowed maybe)

<comment><AUTHOR> We've got something in the works! Added a quick splash page if you'd like to get notified when we release [https://populrr.com/venues](https://populrr.com/venues)

</comment></comment><comment><USER10> Probably don't want to put text over the phone image (on this iPad at least).

</comment><comment><USER11> We do the same thing with ympd. I much prefer it over a proprietary solution.</comment>


Gmail Icons are Hard - <AUTHOR> https://grumpy.website/post/0Px1O7Ukl <comment><USER3> I've said it over and over again:

I speak english, not pictogram. The only platform I've ever seen that got icons right was Windows Phone, because it had a hard-coded "..." button that always did the same thing:

1) Show all the labels, and

2) Show all the additional text-labeled (non-icon) actions that were hidden by default.

So the first thing you did when faced with an unfamiliar set of icons was touch the "..." button which showed you the full list of things you could do.

<comment><USER4> I feel like there are a lot of really solid, user-focused features that windows phone nailed, that now seem basically lost

<comment><USER5> Yep, like all the actions at the bottom of the screen where you could most easily reach them, unlike iOS which places the back button (gesture notwithstanding) at the top _left_!

One of the Windows Phone's designers had a really insightful article [1] about how they designed windows phone fundamentally for a technology native who doesn't need shitty metaphorical leather textures on his glass screen calendar. It is where the famous movement against skeumorphism started (and thank god for that!). WP was doing flat design before it was cool.

On an old MSDN post (maybe?) I remember reading that the inspiration for the Live Tiles was a user whose central interest was to use the phone as liitle as possible to do his task as quickly as he could before he rapidly replaced the phone back into his pocket to get on with real life. I remember creating a new calendar entry in WP7 took three taps from start to finish, not counting typing out the title. There weren't many other fields to fill besides the Title of the entry and the time/date, and it set a default reminder time of 15 minutes before start time. Perfection. Before facebook and the rest dragged the carpet out from under them, you could get your twitter and facebook feed within the contacts app so you could get it all in one place.

Edited to add: I'm on a bit of a love fest venting session so here's more. WP designers recognized that OLEDs were amazing, so they made the phone White Text on Black from the get go! Thus, great battery life. Further, all the icons were also uniformly coloured, making the whole experience so cohesive. All the apps also looked like all the others, so the learning curve was nonexistent. They recognized how little juice engineers of android could suck out of their bloated multi core processors, so they made their phones work phenomenally well on even shitty, single core processors.

I fucking loved windows phone's early verions. It's a shame they've gone away. But an even bigger shame that they had no confidence in their original designers, and ended up adapting the hideous, appalling, atrocious, fucking retarded hamburger menu before they went away.

[1] [http://kruzeniski.com/how-print-design-is-the-future-of- inte...](http://kruzeniski.com/how-print-design-is-the-future-of-interaction)

<comment><USER6> > WP was doing flat design before it was cool.

it was somewhat annoying to watch the community go religious on flat design when "Apple invented it"

<comment><USER7> Hey, I thought Google invented flat! /s

Seriously though, Windows phones sucked for many reasons (including lack of exposed features in the OS, especially in first versions, and of course lack of apps in general), but UX wasn't one of them. I guess they failed in releasing too much of an MVP, and then not following through properly. I continue to claim that Microsoft had a great UX vision for mobile, and that they're the only one with an OS that can turn tablets from consumption devices into productive tools.

</comment></comment></comment></comment></comment><comment><USER8> I'm a developer in his 30s and my time has finally come to be "that guy":

We've already gone through this. It's called mystery meat navigation, and it was so prevalent and discouraged that it even has a wikipedia entry[0]. Hopefully it'll go out of fashion again.

0: [https://en.wikipedia.org/wiki/Mystery_meat_navigation](https://en.wikipedia.org/wiki/Mystery_meat_navigation)

<comment><USER9> ...and now we have that horrible hamburger menu.

<comment><USER10> At least the standard "hamburger menu" opens a list of textually labeled options. That's better than icon-only toolbars.

<comment><USER11> And by the same argument, a traditional menu would be even better.

</comment></comment></comment></comment><comment><USER12> Yesterday, I learned that my sixty-year old mother uses a screen reader on her tablet. Her vision is fine but she never knows what icons mean so the screen reader is able to read out the describing text and decipher them for her.

<comment><USER13> This is a perfect example of why accessibility features are not only for visually impaired! Accessibility done right can bring value for a wider audience.

<comment><USER14> Only if your icons are bad. Otherwise this problem wouldn't exist.

<comment><USER15> I think the problem is that icons are categorically bad for people who are unable to interpret their visual language. I switched my preference to text as soon as the icons were rolled out, and forgot about them. I resented that the designers were imposing a new metaphorical scheme and expecting us all to adapt to it, to suit their own needs. It's the pinnacle of arrogance.

<comment><USER16> Just curious, what do you think of emojis?

<comment><USER15> All the ambiguity of body language with none of the advantages of context. I'm not the first and surely not the last person to confuse crying-tears-of-mirth with crying-tears-of-sadness. And what am I to make of an aubergine or a bicycle?

</comment></comment></comment></comment></comment></comment><comment><USER17> IIRC it used to be all text. I remember feeling the same thing when they rolled out the icon only design and was frustrated that I had to relearn something I had already been using daily (memory is fuzzy, it was many years ago).

Now I am actually okay with it. For a product that is daily use, you get used to the icons fairly quick and am glad it doesn't take that much screen real estate.

What I hated is that it inspired a lot of other products that are NOT meant for daily interaction to do the same thing. For example I probably only interact with the dropbox desktop client once every blue moon and they have icons that make no sense (First icon is two squares for opening Paper which I don't use. Next icon is a globe which is for opening the web ui. All I want to do is revert a file!).

<comment><USER18> Bitbucket has recently changed to an icon theme, with genius icons such as:

1\. <>

2\. </>

3\. a one node graph

4\. a three node graph

5\. a two node digraph

6\. the refresh symbol

7\. an arrow pointing to a cloud

8\. a page

I have no idea what any of these mean and I hate it. Plus, it takes 8 seconds to load anything so if you click on the wrong one it's extra annoying.

If anyone's curious, the answers are:

1\. <>: source

2\. </>: source, as far as I can tell it's the same button again

3\. one node graph: commits

4\. three node graph: branches

5\. two node digraph: pull requests

6\. refresh symbol: pipelines

7\. array pointing to cloud: deployments

8\. page: downloads

<comment><USER19> This reminds me of a t-shirt I got at some Atlassian event a few years ago. It says "You </> me" and I haven't the slightest clue what that means, but it looks cool.

<comment><USER20> it could equally have been "you end me", and the meaning very different...

<comment><USER21> Now I want one of those, with a stylised stab wound blood trickle dripping down from it.

I'll wear it loud and proud at the cafe that's always got Atlassian devs in it round the block from here...

</comment></comment></comment></comment></comment><comment><USER22> I think this article misses a couple important points when it comes to UI AND UX.

I'd argue that an important element of UI is discoverability. Yes, a "A box with downward arrow" is not in and of itself enlightening about what it does. By looking at that icon I am not sure what it does. However, I can discover what it does in very few actions. Clicking on it results in selecting all the emails on the page, and the box changes to checked. Clicking the down icon results in a selection menu with "All", "None", "Read", "Unread" and "Starred"[0]. Clicking on one of those items selects only those items. Given that interaction, can anyone here say they still don't understand what it does? My one criticism is that selecting something like "stared" doesn't filter down to only those items too, so you can now select things that aren't on the page of items you're currently seeing.

Apple's original iOS did not convey a sense of "immediate understanding" that this article demands, but rather focused on discoverability. That is the same mentality that went into make this UI/UX. My point is you can't judge one without the other. Removing all animations from the original iOS would have come close to ruining it. Showing a picture of a Google UI, and criticizing it without allowing it the benefit of discoverability is tantamount to the same lack of context as removing those animations.

Also, following this posts advice:

> Luckily, this menu can be switched to text labels in Settings.

And changing to text button labels[1] doesn't even change that first icon[2], so I'm not sure that post is really for any other purpose than creating material for some echo chamber.

[0] [https://i.imgur.com/D8CogSS.png](https://i.imgur.com/D8CogSS.png)

[1] [https://i.imgur.com/jOaTKDs.png](https://i.imgur.com/jOaTKDs.png)

[2] [https://i.imgur.com/tkhSoom.png](https://i.imgur.com/tkhSoom.png)

<comment><USER23> I'm afraid to click buttons in mobile apps and web pages now. At one point, there was a standardized method, known as "Undo", to assure the user that the changes they're making can be reverted, but at some point along the way we ditched that concept. It's especially worse on mobile where tooltips don't exist, and I have to just have to tap randomly on an icon that looks vaguely like what I want, and pray that I'm doing the right thing.

If I'm lucky, there will be a limited-time Undo button after doing the action (GMail has this on some actions but not others!), but if I hesitate too long or accidentally click on anything but it, it goes away permanently. I'm sure I've lost some important email to the depth of time because of a few fatfinger mistaps.

<comment><USER24> How common was undo really? I don't remember undo functionality being anywhere except in content editor applications like word processors, and that's still the case today.

<comment><USER25> What _isn 't_ a content editor application? Word has it. Paint has it. Outlook has it. Windows Explorer (the file manager) has it. It's universal across Windows and Mac OSes and as universal as anything can be on linux.

<comment><USER24> > What isn't a content editor application?

Well, anything that isn't a text/content editor (or a file system manager, which I had forgotten to mention), so basically the vast majority of computer usage. Settings in applications, navigation state of applications, state of the OS/window manager itself (I'm not aware of a desktop environment where moving or closing a window or application supports an undo feature), etc. Web browsers and most file managers do support back and forward navigation, if you want to count that as "undo."

The comment I was initially replying to talked about being afraid to press buttons in modern UIs because of the lack of undo. My claim is that, except for buttons that change formatting in text/content editors or buttons that make changes in some file system managers, undo functionality has really never existed to my knowledge.

<comment><USER7> > _Web browsers (...) do support back and forward navigation, if you want to > count that as "undo."_

Not in practice, as this feature is universally broken by modern web developers, making it totally unreliable.

You have a good point about undo - it was universally a feature for reverting operations _on edited data_ , not on _application state_ itself. But then again, it was compensated by buttons having reliable tooltips, and most options available in textual menus.

</comment></comment></comment></comment></comment></comment><comment><USER26> There should be a Hacker News "Challenge HN:" post, where you complain (point out) about some broken system and you challenge other people/developers/designers to do better.

Challenge HN: Improve Gmail Icons

<comment><USER27> For open source projects, it makes sense. Otherwise, why should HN spend its time solving a for profit company's product flaws?

<comment><USER28> Mainly for the joy of (possibly, but perhaps unlikely) having your artwork/improvement(s) rolled into a very public product.

</comment></comment></comment><comment><USER29> I agree with the spirit. More precisely I especially agree that static icons cannot easily convey actions; instead they look like things which are supposed to be associated with a purpose, symbols which are usually clumsy, or combined shapes which rarely convey the intent immediately.

On the other hand I find the article slightly dishonest on a couple of points. Not because I believe the icons are particularly obvious, but because the descriptions seem to miss the point. Here goes:

> \- Ok, clock now. This is universally undestood sign that could mean > literally _anything_. What time is it?

The clock is associated with time. In the context of received mail, it seems quite natural that a time-related action would be setting a reminder.

> \- Right-pointing rectangle? This looks most like road sign pointing to some > place, but actually means TAG. Huh?

To me this obviously looks like sticky notes you can add in books or on files to categorize content, a.k.a. quite literally tags.

<comment><USER30> _To me this obviously looks like sticky notes you can add in books or on files to categorize content, a.k.a. quite literally tags._

They're supposed to be the old-school paper tags with a hole in the narrow end [0].

These tags, like floppy's and manila folders, will live on in our iconography even as someone born this decade is unlikely ever encounter the real thing. I was recently amused to explain to my kid what the dialer icon on the iPhone is: "well, a long, long time ago (it's getting close to 20 years now since the Nokia 3310 sold over a 100 million units and we got rid of our landline) we used to have stationary phones in our homes and you would talk into a wired handset that looked like this icon".

[0] [https://www.amazon.com/Martha-Stewart-Crafts-Kraft- Tags/dp/B...](https://www.amazon.com/Martha-Stewart-Crafts-Kraft- Tags/dp/B0052UMTP2)

<comment><USER31> Moreover, things like tags and manila envelopes are very Western or even American. A lot of the world doesn't have these tags or manila envelopes.

</comment></comment></comment><comment><USER32> I feel sorry for the designers that had to work on the redesign that introduced these icons in the first place.

They had to add a bunch of padding around the buttons in the toolbar based on a top-down redesign mandate. Buttons needed to be big enough to be used with fingers/touchscreens, with one glorious responsive UI for desktop and mobile. They discovered that labels didn't fit inside the "safe area" for certain languages, like German (and monitors had lower resolutions then). The icons were a compromise.

And then desktop web stagnated under a "mobile-first" mandate from the top. (Since then, the mandate-du-jour has changed.)

One of the great things about the newest GMail redesign is that there are settings around this -- you can make the padding narrower and you can change the UI to use text labels again.

</comment><comment><USER33> The problem is not that icons are not self-describing (diskette save icon does not describe "save" operation either), but that these icons look like indistinguishable grey circles until you start to focus attention to them.

The same applies to iOS and Android application icons, despite they have vibrant colors. I always can't find what I need, they look the same. I end up using search box if I want to run app that is not on home screen.

</comment><comment><USER9> I have a severe distaste for icons. Look at HN, there's zero thinking involved outside of reading a language. You know exactly what something does, and it can easily be multilingual as a result. I'm hoping the next big trend in design focuses on minimalist interfaces. Nothing but text, and some photos if needed. So tired of all the fluff, particularly on small phone screens.

<comment><USER34> I don't hate icons, per se. I just find them hard to use. For whatever reason, I have to think about icons a lot more than words, even after I'm very familiar with them.

Watching others, most folks don't seem to have this problem - words and icons seem about equally fluid for them. And I'm fine if they don't move - <USER2> remember them by location. But I'm very slow to 'read' icons.

The most common situation that highlights this is tab-application-switching. Those are never in the same order twice, and I have to stare at them until I can pick out the icon of the app I'm thinking of. I've looked for hacks that would replace the icons with words, but haven't seen one, at least on MacOS.

<comment><USER35> I absolutely have the same problem. I think other people do to, but now I'm not sure if I've observed this or I'm just assuming other people have the same problems as me.

</comment></comment></comment><comment><USER36> So you read HN. Hacker news. You set up iSync (mbsync) and all Your Gmail via IMAP. Since you are a hacker, you use emacs (or if you are less fortunate :-) vim) Now configure mu4e, notmuch or gnus. All Your actions are now a simple keystroke away: C compose R reply F forward And never bother with Gmail interface :-)

<comment><USER3> There's delicious irony in how many jargon-y terms are in here that would be, to non-geeks, just as opaque as those icons.

\- HN

\- mbsync

\- IMAP

\- emacs/vim

\- mu4e/notmuch/gnus

<comment><USER36> Yes you are right. However, this is not the New York times nor the economist nor the guardian. This IS hacker news. :-)

</comment></comment></comment><comment><USER37> First thing I do is switch to text labels. Icons are proven to be harder to recognize.

Images are great for conveying complex information but icons are much smaller and harder to recognize, especially in gmails soft bubbly grayscale icons that refuse to use any colors or even borders.

</comment><comment><USER38> Maybe I'm crazy, but I think those icons do a pretty good job...

<comment><USER39> I think the idea is that you know what they do from having learned and interacted with the icons. If you're a fresh user, it could be a pretty unintuitive learning curve.

<comment><USER40> I've been using gmail since you needed to have an invite. I just learnt that:

> Two envelopes in a stack means 'mark as read'

from this article. I had no idea what it did before.

</comment></comment></comment><comment><USER41> Under Settings -> General

select Button Labels: Text

Life is too short.

<comment><USER42> Unambiguous, non-disruptive and not distracting. Life is to short to live by the whim of profit-led iconography which aims to keep people guessing and attentive whilst distracting them from the real utility and product necessity.

</comment></comment><comment><USER43> If you want to say something and be understood, use words in a commonly-used language: English. Using icons is, effectively inventing new words. Nobody has seen those words before: they are the designer's private language.

<comment><USER44> That's a provincial point of view. Despite Anglo hegemony, billions of people prefer non-English.

Anyway, English invents new words or new meanings all the time. What does a "cloud" have to do with webservers?

<comment><USER45> > What does a "cloud" have to do with webservers?

I've always assumed it had to do with the common use of a cloud to refer to the internet or other network on diagrams. With a cloud being used because it conveyed a sense of "the unknown" or "uncontrollable." Which is an interesting meaning progression to the current version of "cloud."

<comment><USER44> > common use of a cloud to refer to the internet or other network on diagrams.

You know that because you are a network software developer. In summary, though, "Cloud icon represents the cloud, and we use the word "cloud" because ... we use a cloud icon to represent it."

</comment></comment></comment></comment><comment><USER46> I had no idea the icons could be changed to text in Settings. I know what they all do, but there's something about them that bugs me a lot. There's always a slight hesitation where I think about what they mean.

</comment><comment><USER47> I like to imagine that the people that get annoyed with poor iconography are the same people that use Vim and other esoteric software.

Instead of commenting on google's design, we could be commenting on software that isn't proprietary, closed source and anti-consumer, with access provided for free solely to enable data mining and maximise ad revenue.

<comment><USER48> I hate poor iconography.

A while ago it took me a good 15 minutes to figure out how to mark an email as "unread" in the Gmail Android client. Apparently an envelope icon means "mark as unread".

The newish (within the past couple years) navigation icons on Android are great: a left pointing triangle, a circle, and a square. At least the triangle points the same direction as old back button.

Disclaimer: I do use Vim when SSHed into a server because that's the CLI editor I happened to learn and it supports regex search.

<comment><USER49> Also, the "Mark as unread" button is only present if you are in your inbox with the email selected. There is nothing analogous to the desktop's "Mark as unread" which is at the top of an open email, and returns you to the inbox when used. Also, there is no indication that the emails are selectable at all. The icon to the left of each email is a portrait of the sender, which in no way corresponds to the action of selecting an email.

</comment></comment></comment><comment><USER50> I've been using basic HTML Gmail since the new one came out. [https://support.google.com/mail/answer/15049?hl=en](https://support.google.com/mail/answer/15049?hl=en) Works great with vim-like browsers and has no icons, just text.

</comment><comment><USER51> I have a hard time designing the UI on [https://editfight.com](https://editfight.com) because it's supposed to be easy and simple and obvious on both desktop and mobile, but there's almost no space on mobile. So I resorted to icons at first and then moved half the icons to a pop out menu and turned them back into words. The only icons left are ones that are either obvious or easily learnable and memorizable. And I had to change a few and even draw a few myself (SVG) because they were too similar to each other. There's still one I'm not super happy with but it's a very strange feature that only makes sense when you finally need it. Icon design and UI design in general is very hard to get 100% right for everyone.

<comment><USER52> Odd, for a site calling itself "editfight" you sure are quick to ban people. Maybe you need some kind of interstitial or landing page if you want to explain what your idea is (it's clearly not just for people to randomly doodle).

<comment><USER51> The name editfight.com is kind of a historic name and every time I've suggested changing it, all the regulars incite in an uprising and demand I leave it alone. Sorry for the confusion though. I just updated the site to shows the rules and a brief explanation of what it is when visiting it for the first time. Thanks for your feedback :)

</comment></comment></comment><comment><USER53> Reminds me a bit of this toolbar in Google Sheets. The last option is not underline (it's text color). Always trips me up.

[https://imgur.com/a/7w1NwvO](https://imgur.com/a/7w1NwvO)

</comment><comment><USER54> Oh yeah!

I remember I was looking for a "mark as unread" in the android gmail app, never finding it for a long time until I tried that icon, wondering what it was. It was the mail icon button.

<comment><USER55> can we also spend a second complaining how the mark as read is not contextual in the web version of gmail? I hate that.

</comment></comment><comment><USER56> It's not advertised, but Gmail still supports a "basic HTML" mode, which uses real text and real buttons/menus/links for everything. I think it's nicer than the new all-gray, all-icon, all-JS version (except for a couple annoying bugs which will probably never get fixed).

They've removed any way to enable it from Gmail itself. You have to search Gmail Help ("See Gmail in standard or basic HTML version"), which has a magic link you can visit to enable it.

<comment><USER57> Also, if you have a crap connection, Google will try to detect your speed and sometimes offer to switch you to the basic mode.

</comment></comment><comment><USER58> In the past hover text helped to fill in the knowledge gaps when met with unfamiliar or ambiguous icons. On mobile and other touch devices, where there is no mouse, this breaks down. We could do with some kind of replacement for hover text on touch UIs, maybe a return of the "What's this?" question mark button Windows used to have.

<comment><USER44> In a well-built mobile app, long-press is "Hover"

<comment><USER48> This is why "discoverability" sucks. I've used Android for 9 years, and I'm aware of long-pressing but I didn't know it was a substitute for mouse- hovering. Is this standard? I thought it was a substitute for right click.

<comment><USER44> You're right that you can't differentiate "Hover" from "context-click" on mobile. But there's not _need_ to have two separate actions for "show info tooltip" and "context menu", since they don't interfere.

Poking at something to see what it does is something most people do since toddlerhood. The only challenge is getting over your fear that irreversible operations are triggered on touchdown not touchup.

</comment></comment></comment></comment><comment><USER59> What's the implication of this article?

Is it that Google did not do user testing?

Or they did user testing and found the icons work fine?

Or they know labels work better, but intentionally chose to use icons anyway?

"I don't like X and it's obvious that Y would be better" is a fun topic, but I'm not so sure why people are so quick to accept an anecdote as gospel.

</comment><comment><USER60> Wow, I have the opposite experience, but I'm pretty accustomed to GMail and it's icons.

Up until this moment I'd been annoyed that my action bar in GMail was text- only after the update to the new interface. I was even wondering why the author was writing about the _old_ GMail and went searching through the comments looking for others who were just as confused and checking GMail settings (it was there—I just missed it).

The icons are much easier (for me) to decipher _upon quick glance_ , once I know their meanings. The text requires me to actually read the buttons before clicking, which is slower if I'm not doing it repetitively (like tagging/archiving a weeks worth of emails on a Friday).

That said, I'll _always_ prefer a combination of icons and labels.

</comment><comment><USER61> At least in the browser I can hover and see some help text. On mobile it's a shot in the dark.

</comment><comment><USER62> To everyone wanting text buttons, consider that a surprisingly large amount of the population has literacy problems (perhaps an email client isn't the best example for this, since you're using it to read and write words, but consider the general case). Icons are going to make their life easier (assuming there isn't room for icons+text all the time). This is an counter-point/trade-off to vision-impaired accessibility where you need words everywhere.

Icons are hard (to get right) in general. Do you stick with skeuomorphisms when half your user base know them well, but the other half have no idea what they mean (e.g. floppy disk to save)?

<comment><USER63> But if literate people don't get what the icons mean, why would less-literate people?

<comment><USER62> Maybe some people are more wordy, and some more visual? You'd be surprised at how people adapt to not being able to read - there is literature of children who 'fake' reading - they essentially memorise the shape of a thousand or so words (over the course of their school) so it appears they can read to some degree, but have no idea when they come across a word they haven't memorised.

</comment></comment></comment><comment><USER64> Seems to me like this person is making a mountain out of a molehill. The functionality of the icons can be learned quickly and they look aesthetically better than text.

You can't make an icon that is naturally unambiguous to everyone, everywhere.

</comment><comment><USER65> The only intuitive user interface is the nipple, everything else is learned.

</comment><comment><USER66> The icon that gets me is the "paperclip" for Attach vs. the "chain link" icon for Hyperlink.

Two icons in the toolbar, both small rounded metal loops. I have to hover for the tooltip every time.

</comment><comment><USER67> People often make the mistake of thinking text and icons are two ways of doing the same thing

Labels are good at telling you what things are, but finding specific frequently performed actions in a list of text that all look similar will yield frustration

Icons (and especially icons with colour, or icons plus colour) are good at allowing you to quickly find something you're already looking for, but expecting icons to perform the job of labels to provide initial information will yield confusion

</comment><comment><USER68> > This means move, but even since Windows 95 days it was clear nobody is going > to come up with a good metaphor for move. Nobody did.

Why not a cow? Everyone knows cows go mooooooo-ve :)

<comment><USER69> _Comment est-ce que je peux déplacer cet e-mail ci? Il faut appuyer la vâche? Pourquoi?_

I realise you were only joking but it does illustrate why i8n icons are difficult.

</comment></comment><comment><USER70> Most of these icons would be much clearer if a dabble of colour and depth was added. All these flat design aficionados have only aesthetics in mind, not usability.

</comment><comment><USER71> Three stripes or three downward arrows are the dumbest invention. Three horizontal dots already existed, and literally means ellipsis from other contexts.

</comment><comment><USER72> Actions that have arrow-like things in mail: forwarding, replying, moving mail to a mailbox. We need better ways of saying these things.

</comment><comment><USER73> Once I learned that I could switch to text labels in Gmail, I can never go back. Even though I've learned the icons, I am still more productive with text labels instead.

Even knowing the icons' meanings, my brain has to pause a second to think about what they do.

</comment><comment><USER74> This website reminded of littlebigdetails[0] when it comes to analysing user interfaces. The difference is that the latter points out what's good about them.

[0] [http://littlebigdetails.com/](http://littlebigdetails.com/)

</comment><comment><USER75> I've noticed an increasing trend of designs that constrain themselves to the FontAwesome set, and it's not uncommon that the same icon on different sites triggers entirely different actions.

<comment><USER76> Yes, this. I don't mind it for cosmetic purposes, but it's getting used for interfaces in confounding ways.

I hit a personal wall of "will & interest" this weekend trying to re-learn an app I've used for a long time that updated with some interface changes.

I think it's actually possible to reach a "too many interfaces" limit.

Or at least I'm getting there.

</comment></comment><comment> V-2 Gmail isn't the only service guilty of that.

Here's an icon from the Outlook web mail app: [https://ibb.co/ic66Qd](https://ibb.co/ic66Qd)

What does it mean?

</comment><comment><USER77> I always hit Gmail's in app "back" button when I want to reply.

I honestly had to ask someone how to reply to an email in gmail.

</comment><comment><USER78> I think in most applications this is important but in my email, I value density above all else.

</comment><comment><USER79> I don't have this problem in mutt

</comment><comment><USER80> REALLY HARD

</comment><comment><USER81> Design for the sake of design...

Companies spend too much on designers.

<comment><USER82> They spend too little. The problems that real design solves have nothing to do with this. Anyone can just pick icons from a library and make them buttons. How easy is to blame a designer for these choices.

People who say "design for the sake of design" are exactly the people who need design.

For starters, everything is designed. Show me one human-produced thing that wasn't actually consciously designed by someone. Is that design for the sake of design? There's a difference between good design and bad design. It's important to learn how to tell the difference, but more important to learn how critical to success is good design (regardless if it comes from a trained designer or not.)

<comment><USER83> Sure, who could argue that bad is better than good? :)

The question is - But, Why. I'd bet half a paycheck that the only people who really really care about the new "cool" designs are (1) Bosses looking to take credit (2) Bored tech writers looking for content (3) UX Peers looking for validation (4) Tech people looking for new toys. Normal folks just want all that fancy UI stuff to go away. They would be just as productive on a UI based on Mac OS 8.

</comment></comment></comment><comment><USER84> Why does the bottom of the page say "All fights retarded" ?

wtf?? Totally unnecessary.

</comment><comment><USER85> All of these icons have tooltips that appear within 100ms of hovering over them. Surely there is a better part of the new gmail UI to pick apart?

<comment><USER86> Isn't that kind of a poor choice then if the intent is to have the user hover over the icon? Also what about touch?

If there was a functional advantage of the icons that would be great. But I'm guessing it was chosen just to "look prettier".

<comment><USER87> Icons take up less space on the screen, which is useful if you are using a smaller browser window (or a phone screen).

<comment><USER88> But the trend, and the default GMail settings for UI spacing is far too spaced out. I'm finding it difficult to use some of the newer UI's with such wide spacing, without using the app fullscreen. Microsoft CRM, I'm looking at you. It's 100% not usable unless it's full screen.

</comment></comment></comment></comment><comment><USER89> Their product managers and designers spent too much of their "clutter budget" on stupid stuff so they felt they had to reduce the clutter by making those things that should have been icon+text buttons into icon-only buttons.</comment>


Top Programming Languages That Generate Software Vulnerabilities - <AUTHOR> http://news.softpedia.com/news/top-programming-languages-that-generate-software-vulnerabilities-497101.shtml <comment><USER2> When did iOS and Android become languages?

</comment><comment><USER3> Interesting. Java generates twice as many security flaws as C++ (per megabyte of source code), but C++ generates more critical flaws. .Net generates more security flaws and more critical flaws than C++.

Looks like sandboxing and garbage collection aren't a cure-all...

<comment><USER4> There are two separate issues. One is how prone to security flaws the language itself is. The second is if there are library routines that introduce flaws.

This study is highly dependent on the exact code base analyzed, and especially on the quality of the analysis tools with regard to false positive rate.

I suspect this is largely GIGO but will try to take a deeper look at it at some point.

</comment></comment><comment><USER5> How is it possible that a language can generate a vulnerability?

</comment><comment><USER6> softpedia? Really?</comment>