Ask HN: Simple contacts web app - <AUTHOR>

I'm looking to create the following simple flow in a web app:
1. A user signs up with an email & password
2. A user can add a list of contacts (e.g. firstname, lastname, phone)
3. A user can add multiple events to each contact.
Thoughts on what framework to use to get an MVP up and running? <comment><USER2> I'm not sure the product has value. Look, if you want to learn a framework that's great, but I wouldn't place much hope in the concept as it's been done in many places.

I would recommend using Ruby on Rails, maybe trying Code Ingiter (PHP) or even giving ASP.Net MVC a try.

If you are looking to learn a framework, there's hope, but if you are looking to create a viable product, you might want to dig deeper.

</comment><comment><USER3> I'm confused what this offers that existing Contacts & Calendar solutions don't?

<comment><AUTHOR> Nothing as yet - it's to build a simple app to enable me to learn a framework and have a rough idea of its strengths / weaknesses.

<comment><USER3> Well if the whole point is to learn a framework, surely the determining factor of what framework to use is more related to the language you want to use, what you already know, etc, rather than how well it will make a contacts app??</comment></comment></comment>


Show HN: every PowerPoint presentation, from now on, should be interactive - <AUTHOR> http://www.netclick.me

<comment><AUTHOR> What? No one wants to identify the errors in the predicate logic example?</comment>


Why even a moth's brain is smarter than AI - <AUTHOR> https://www.technologyreview.com/s/610278/why-even-a-moths-brain-is-smarter-than-an-ai/ <comment><USER2> This study was discussed here 7 days ago (67 points, 14 comments):

[https://news.ycombinator.com/item?id=16363479](https://news.ycombinator.com/item?id=16363479)

</comment><comment><USER3> "One of the curious features of the deep neural networks behind machine learning is that they are surprisingly different from the neural networks in biological systems."

What a silly thing to say. It's pretty depressing that there are obviously scientists, engineers, and investors out there with the arrogance and/or naivete to believe that software neural nets are something more than mere conceptual mimicry of layman-level theory about how actual brains work.

What's really sad is that however good brains are at what they do, it's also pretty silly to think that emulating them more closely is a good way to improve digital computer systems, which have entirely different strengths. Yes, take what we can learn from how brains process information efficiently, but don't try to force an incomplete and inaccurate model of brain function onto non-biological hardware and expect it to be anything more than a poor brain and a poor computer.

</comment><comment><USER4> Maybe the millions of years they had to perfect their brains for the tasks needed for their survival has something to do with it; modern computing has not even one century in the making.

<comment><USER5> More likely, the substrate on which the action can take place.

</comment></comment><comment><USER6> Naive/silly question: are we getting anywhere near actually being able to exploit all these "natural computers" that exist in the wild? Are we getting close to being able to use the brain of a moth to compute things with higher quality than what current AI is able to produce? And if so, how close are we to actually taking advantage of all that compute power, for instance to mine bitcoin?

<comment><USER7> This is one of the most terrifying comments I've ever read. The prospect of harvesting or growing brains to use as computing devices isn't just some weird thing from cheap scifi anymore, but something someone out there is actually researching and trying to make work at this very moment.

Growing organs for transplants or meat for consumption is one thing, but using the brain of a living creature purely as a tool is a whole different kind of horror.

<comment><USER8> 2005:

[http://www.research.ufl.edu/publications/explore/v10n1/extra...](http://www.research.ufl.edu/publications/explore/v10n1/extract2.html)

You'll probably be able to find earlier examples.

</comment></comment></comment><comment><USER9> The title is quite missleading, the article does not explain at all "why even a moth's brain is smarter than AI", it doesn't even prove the statement.

It just goes "octopamine ... something something, biological neural nets don't use backpropagation".

</comment><comment><USER10> Wonder if the Octopamine acts as some kind of bucket brigade algorithm to reward a recorded sequences of stimuli/actions pairs right before a positive result.

kind of like smell this go left, smell this go right...you win...reward previous actions.</comment>


Michael Dell doesn't see smartphones, tablets as a threat to PC sales - <AUTHOR> http://www.itworld.com/hardware/239537/dell-pcs-not-under-threat-tablets-or-smartphones

<comment><USER2> Do you know how many people still don't really use their PC, and therefore get all their web/communication needs fulfilled by their smartphone. Many of them won't keep buying PCs. Well, laptops. PCs are already out.</comment>


Brexit Shows a Global Desire to Throw the Bums Out - <AUTHOR> http://time.com/4381539/brexit-global-populism/ <comment><USER2> The EU experiment has failed. The currency alone is proof of that. And now that several of the member states are economic sinking ships, the stronger nations are saving themselves before they go down with them. It'll be interesting to see what Germany does next. Either way, good on the UK, they don't need the EU member states and in they're much better for it.

<comment><USER3> So California should break off by this logic?

What about London from the rest of England?

Why not transform everything into tiny autonomous little city states?

Perhaps the nation of San Francisco?

The problems of the 21st century; climate change, desertification and its corresponding migratory effects, fresh water depletion, sea level rises, the devaluation of labor capital, avoiding another world war... these can't be addressed by tiny little autonomous nations working in their own self interest based on some fetishized national narrative.

That's what caused the problems to begin with. Capital and nature doesn't respect borders. There's one planet. Any subdivision past that is an artificial invention and permits writing off consequences and shunting of responsibilities.

We're all adults here and it's high time we start acting like it.

<comment><USER4> A great deal of those problems are directly the result of large nation states and industrialization.

Things that work in California don't make sense in the rest of the country-- after all, look how well they've handled their water and regulating their own usage.

Similarly, I don't think anybody from rural US would look kindly on progressive values being instilled on them--nor anybody in a liberal city having to put up with the opposite.

The advantage of small government is that it allows flexibility and accommodation for its population.

<comment><USER3> There needs to be some kind of institution.

Engineers have systems that seem to work.

For instance, humanity has settled on a very complex set of evolving standards in order for me to input this content on a smartphone and have it be read by billions of others around the world.

There needs to be a W3C/IEEE of the political world. Unicode, IPv6, HTML5, we can do this...

</comment></comment></comment></comment><comment><USER5> We will shortly be getting a whole new set of bums to replace the old ones, no doubt they will continue to blame the "foreigners" for all the problems that inevitably come along.</comment>


Jump in U.S. traffic deaths leads the world - <AUTHOR> http://www.courier-tribune.com/news/20180529/jump-in-us-traffic-deaths-leads-world <comment><AUTHOR> Put down the phones.</comment>


Apple's Misleading Use of Location Data - <AUTHOR> Apple takes great pride in their adherence to their core competency of protecting the user and their data. Just look at their announcement today about their updated privacy policy.
Unfortunately, though, there is a misleading usage of location data. If you turn off location permissions to the "Find My" app in "Settings", "Privacy", "Location Services", "Find My" (with a title of "Find My at the top) and change the "Allow Location Access", you won't see your location in the app, but your friends that you've shared it with will.
Apple Security responded that this has to be done though "Settings", "Privacy", "Location Services", "Share My Location" (which also has a title of "Find My" at the top) and toggling the "Share My Location" switch.
Technically they are correct, but common Apple, to the average user this maybe be confusing and misleading. If I was to turn off my location for an application and I myself then can't see my location within that app, it is baffling that a different user would be able to see my location because actually the location isn't being polled from where I thought I turned it off, but rather another entity that I wast not aware had to be turned off.
This could be akin to the idea of turning off location services for Messanger and keeping them for Facebook and friends still seeing your location on Messenger.
Apples please don't do this "technically" speak and just be upfront with the users more clearly. Location data is really sensitive and if people want it turned off, the mechanism to do so should be more clearly labeled. <comment><USER2> This is literally how my girlfriend caught me cheating... would have been nice if they fixed this a month ago

<comment><USER3> Alternatively, maybe a month ago you could have not been cheating.

<comment><AUTHOR> Welp, could have been a totally different case of someone trying to surprise someone instead?

<comment><USER2> Yea, I tried that excuse. I said me and her best friend were just planning a surprise party for her. But the whole Saturday at 3AM thing didn't really add up.

</comment></comment></comment></comment><comment><USER4> Yeah, that definitely sounds misleading. Hopefully they'll fix this.

</comment><comment><USER5> Typical Apple these days. It's not the company we used to love and rely upon any more.

</comment><comment><USER6> How could Apple let this go? I tried it out and it was true! Outrageous. :O</comment>


Ask HN: expanding on MVC with frameworks for declarative UI description? - <AUTHOR>

Having written a bunch of UI code for iPhone I am now tempted to design my own framework to factor out reusable parts. However, before I begin I would like to tap into collective wisdom of this community - surely someone has done similar work before and if so I would be glad to learn rather than reinvent.
Here's how I see the structure of a single "page" in an application, expanding on MVC:
1. The Model - a software component and backing storage which provide access to the data. The important thing here is that Model itself must represent data how it's structured in the user's head, not how it's really stored in e.g. a relational database.
2. The Model Schema - a declarative description of types,  relationships, and arity of the data entities stored in the Model. Model Schema could be an XML file, for example.
3. Text (Copy), possibly localized. A simple key-value text file would likely suffice.
4. Layout description - list of UI controls and their design attributes (colors, fonts, margins, alignment, grouping/proximity etc). This also includes binding from controls to the Model Schema and to Copy. Layout description also can be a declarative description, such as an XML file.
To make this whole thing come alive I would need a layout engine that can take layout description, create UI controls, populate them with data according to bindings and place them on screen according to design attributes, taking content into account. The difficult part is handling arity.
If I can pull this off, I can see enormous benefit: a designer, a developer, and a copy writer could be iterating independently based on a single common document - the Model Schema - and seeing the complete animated result of their work as they make progress.
So what are the closest things to this that someone else has already done or tried to do?
Note that existing iPhone UIKit cannot do content-sensitive layout, all layout positioning is independent of content and so often looks poor with truncated text or large areas of whitespace - this deficiency and the countless hours spent aligning text on screen were the primary motivators behind my thinking. <comment><USER2> Might be worth looking at Reaction for ideas: <http://search.cpan.org/dist/Reaction/>

In Reaction the model is split into "Domain Model" and "Interface Model". Also the View is broken down into layoutsets, widgets & viewport components.

Here's some inks which may (or may not!) show some enlightenment on the methodology behind Reaction:

* [http://search.cpan.org/dist/Reaction/lib/Reaction/Manual/Int...](http://search.cpan.org/dist/Reaction/lib/Reaction/Manual/Intro.pod)

* [http://search.cpan.org/dist/Reaction/lib/Reaction/Manual/Ove...](http://search.cpan.org/dist/Reaction/lib/Reaction/Manual/Overview.pod)

* <http://search.cpan.org/dist/Reaction/old/Manual/FAQ.pod>

</comment><comment><USER3> Although not a direct answer to your question, I do think Qt's Kinetic (<http://labs.trolltech.com/page/Projects/Graphics/Kinetic>) might be a good source for inspiration. It contains a declarative UI markup and scripting language called QML, that looks roughly like JS/JSON. An old example can be seen here: [http://labs.trolltech.com/blogs/2009/05/13/qt-declarative- ui...](http://labs.trolltech.com/blogs/2009/05/13/qt-declarative-ui/)

I am very curious about how Apple would react to something like this though. It's obviously a good idea, but they have been really frantic about alternative solutions to these kinds of problems :)

<comment><AUTHOR> Thanks for the links, guys, I will look into them.

I'm not worried about Apple for two reasons:

\- The layout engine I have prototyped (there is no binding, only layout proper) operates on native iPhone controls, i.e. it does not create a new abstraction layer on top of UIKit but rather extends it form the side with smart sizing and positioning. I think it's very important to avoid creating leaky abstractions and I plan to keep doing things this way. In other words the layout description describes layout of native UIKit controls, not some abstract presentation of data.

\- I'm no Adobe, and I'm not likely to attract attention to myself.

</comment></comment><comment><USER4> You should read more about how to build an application on Android, at least in terms of defining UI. I am tempted to try to create a UI framework that can parse these same xml documents and create iPhone UI.

<http://developer.android.com/guide/topics/ui/index.html></comment>


The Size of the Derivatives Bubble = $190K Per Person on Planet - <AUTHOR> http://www.globalresearch.ca/index.php?context=va&aid=12753 <comment><USER2> The title of this submission is misleading. The quadrillion figure represents nearly ALL derivatives -- not just those deemed by someone to be frothy. About 1/3 of the figure encompasses interest rate derivatives. I haven't heard a lot of banter that the risk of rate fluctuation is mis-priced.

Also, what SHOULD the sum total of the value of the derivatives market be? The insurance I buy on my house is a derivative -- a contract whose value fluctuates wildly based on the performance of the underlying physical asset. Since almost all homes in the US are insured, the sum total of the insurance market is likely substantially more than GDP. What if there's a black swan event, like all of the US getting wiped out? Whatever will we do?

To further ease concern, many of these derivative contracts are likely offsetting. There will be winners and losers, but it's likely that there are just as many people protecting themselves from low interest rates as high interest rates, for example.

My favorite meaningless quote:

"...a lot of the problems of Enron in 2000 were brought on by leveraged derivatives and using derivatives to hide problems on the balance sheet."

Guns don't kill, people kill. Someone did something bad involving derivatives. So what?

</comment><comment><USER3> Isn't this just an alarmist way of saying "nobody knows the real value of these derivatives contracts"?

<comment><USER4> The real value is zero minus applicable fees.

<comment><USER5> I'm a bank. I gave a mortgage to a responsible homeowner who has bought a house that is within his means. Now that I've given this loan, a lot of my money is stuck and I can't give loans to other people. However, I know it's a good loan with a very low risk of default. So I turn and say "Hey, I've given this loan, and here are the details which explain how much this loan is worth in non-real terms. You'll have to guess at the market interest rate to figure out the "real" (economic term) "value", but that's doable. Would you like to buy it from me?"

If someone agrees to take possession of the loan, they'll have to reimburse the bank. Hey look! The bank has capital to repeat the process until it can't find any buyers of these loans. It's a good, honest bank, so it doesn't do anything fishy to move more loans. Eventually, we hit an equilibrium between people buying these loans, the bank holding loans, and people getting mortgages.

Now you're telling me a derivative, the thing the bank sold, has no value? Sir, I'm going to have to disagree.

<comment><USER3> Presumably, the federal government doesn't make CDS speculators whole after their counterparties BK.

</comment></comment></comment></comment><comment><USER6> did you know that BIG NUMBERS are SCARY? Try these on for size: 17! 542! 24,986! BOOGA BOOGA BOOGA</comment>


Why functional programming doesn't catch on - <AUTHOR> http://confusion.tweakblogs.net/blog/1418/why-functional-programming-doesnt-catch-on.html <comment><USER3> Although a lot of functional programming tutorials are very mathematical like the author says, not all of them are. Real World Haskell (<http://book.realworldhaskell.org/read/>) is a great book on Haskell that shows how to actually solve real world problems using functional programming. Maybe with enough references like this FP will catch on? Or maybe lack of good documentation isn't what's holding it back?

</comment><comment><USER4> I think the best way to prove functional programming (or your favorite programming paradigm/practice/methodology/language) is as much an advance as you say it is is to implement something worth paying money for in it.

I have a deep, abiding affection for Ruby, for example. A few years ago it would have been a tough sell. Then along came Rails and people constructively demonstrated "Hey, this language is not quite C or Java-esque, but there are persuasive reasons to use it. Why, metaprogramming techniques let you build a web application framework which allows impressive tech demos in 15 minutes. And look, if you go a bit beyond the 15 minute demo, you can actually build applications that people will pay money for -- faster and easier than you could before."

<comment><USER5> If you don't mind answering, what did you write the software for your startup with?

<comment><USER4> I sell a desktop application that is written in Java. My web site is written in Rails (with the obligatory Javascript bits).

The distinction between the two is blurring these days. The core feature of my website is a backend where my freelancers enter new content, which is then operated on by my program, and turned into a page on my website advertising "Here's a taste of content you find compelling. You could make something like this if you only pushed yonder download button". This was originally intended to be mostly for marketing and SEO.

Then I got a bright idea: wait, I pay people to add to that content every month. What if I could update the application with it automatically? My users don't care about the distinction between code and data one iota: from their perspective, adding more content to the program improves what it can do. So I offer access to the new content as one of the benefits of purchasing the application -- free at the margin for me, high perceived benefit to the customers. Its like having a program that gets an automatically generated .1 upgrade every month.

</comment></comment></comment><comment><USER6> The absence of something like a "Java Pet Store" for FP was what drove the topic for my MSc dissertation that I finished last year: I basically implemented a simple set of requirements for a publishing-workflow system in both Java and Haskell and then set out to evaluate the differences that the two approaches had from a software engineering perspective [<http://www.lars- oppermann.com/dis/dis-lopperma-final.pdf>].

The Haskell version turned out to be much more compact and some parts of the business logic could be expressed in a really straightforward way. The Haskell version also had a meta-programming based mechanism for automatically deriving and parsing XML representations of the domain objects. The persistence layer could also be made very unobtrusive due to Haskell's type-classes.

Nevertheless, the absence of extensible data types and the clunkiness of Haskell's record system made the domain model rather unwieldy. This is not a necessary limitation of FP. It rather seems that most users of FP today don't need such facilities because they are not normally building systems that require these kind of models.

It's also very important to note that object oriented programming and FP are not conflicting. Mainstream OOP languages tend to embrace an imperative execution model (Turing Machines) and FP languages are modeled around Lambda Calculus. Projects like Scala show how FP and OOP can augment each other nicely.

<comment><USER7> Interesting. Thanks for the link to your report.

</comment></comment><comment><USER7> I've tried to learn FP a few times, but I never understood the advantages. Most recently, I opened up Armstrong's Erlang book.

The power of Erlang seems to be due to the fact that processes and crashes are part of the language, and the language makes it fast and simple to create processes and handle crashes. This (esp the process part) can be implemented in a non-functional language.

It wasn't obvious to me why the functional nature of Erlang gave it any power.

It seems to me that things like the Erlang book example where they provide reliability to any arbitrary app can be implemented in C++ using a base class + virtual methods.

I would appreciate any "killer articles" which will make me "get it".

<comment><USER8> The idea behind FP is to minimize or eliminate implicit state change.

This has several advantages. The first is that it eliminates errors caused by unexpected state change. This is a larger class of errors than you might expect.

The second advantage is that FP applications are easier to unit test. When given a certain argument, FP functions always return the same value, so if f(1) is 2 in your tests, you can be guarenteed it'll be 2 in your application, too. FP generally more predictable.

The final advantage I can think of is concurrency. Concurrency in imperative languages is made harder because a data structure referenced by one thread can be mutated by another. In FP, data structures are immutable, so this problem doesn't occur.

</comment></comment><comment><USER9> I like this quote from the comments:

"I don't have a clue how one would be able to build a gui with it, or how one can easily interact with a database."

Because SQL is functional programming. Functional programming doesn't just mean Haskell, it also means Microsoft Excel (which, I've been told, is the most used programming platform in existence).

<comment><USER10> I disagree. SQL, by definition, is natively nonfunctional. The concept of a database _requires_ state. However, you can write functional-esque (monadic) layers on top of SQL.

Excel is basically a wrapper around spaghetti code. It's great for small presentations, but using it for real programming is incredibly risky. There are an enormous number of stories floating out there about business apps written in Excel that turned out to have subtle but sometimes disastrous bugs due to random human errors as well as poor maintenance when the "program" changed hands.

<comment><USER11> If you don't use UPDATE or DELETE, then you're treating SQL as a static- single-assignment language.

This is pretty much what I do at work; we have massive quantities of geographic and linguistic data that we have to translate to [REDACTED], and we do this by uploading it all into PostgreSQL and then running through a long sequence of "CREATE TABLE foo AS SELECT hairy_expression FROM bar;" statements.

<comment><USER10> Good point.

For the time it was written (1970s, I believe) the SQL language was way ahead of the curve compared to the languages being used in enterprise.

</comment></comment></comment></comment><comment><USER12> the simple answer is that functional programming makes the easy things trivial, but for the hard things FP makes it obvious that you need to do something clever that involves a capacity for abstraction in design that few people have. There is no way to sweep the complexity under the fuzzy rug, you need to knit it a tea cozy that's the right shape and mechanical properties

<comment><USER13> _something clever that involves a capacity for abstraction in design that few people have_

Anyone smart enough to use C++ professionally is smart enough to use any language.

Remember that people once built enormously complex systems in _assembly language_. Academics have always vastly underestimated the intelligence of commercial programmers.

<comment><USER12> How many truly gifted c/c++ programmers are there as a fraction of all who professionally use these languages?

<comment><USER14> As a percentage, it's probably smaller than the percentage of gifted programmers using lisp/haskell/erlang.

However, it's a small percentage of a huge number. It wouldn't surprise me at all if there are more talented C/C++ hackers than FP hackers.

</comment></comment></comment></comment><comment><USER15> "Pure" FP languages eliminate state. All programs contain an (implicit or explicit) model of the domain they are computing on. Many aspects of the world (domains) that we need to model are stateful. Our programs, in modeling those domains, often must be stateful. This is why it's hard for programs to be entirely functional.

On the other hand, state dramatically complicates reasoning about code, since outputs are no longer purely a function of inputs. Moreover, even with lexical scoping, it's not immediately clear what the state variables are a function of. As the scope of state variables increases, it becomes ever harder to determine what a state variable _is_ a function of. This is why programs should be as functional as possible.

Solution: a language like Clojure or Common Lisp, which naturally encourages a functional approach while allowing side effects when neeeded. Clojure has some advantages over CL in this regard, since it has several clever mechanisms such as agents and software transactional memory to control side effects.

<comment><USER8> Pure FP languages eliminate _implicit_ state. You can still have state; it just has to be explicitly passed in as an argument.

<comment><USER16> Or handled as a Monad.

</comment></comment></comment><comment><USER17> Microsoft doesn't matter much anymore, but F# will be integrated to Visual Studio 2010, bringing a very powerful functional language to all .net/mono coders. And I'm sure there are quite a lot of them. So the argument of lack of decent library or nice IDE will fall apart (and I heard it quite a lot) : we'll see how well F# fare on the .net scene.

I'm quite enthusiastic about it, since F# is actually a very nice functional language, with strong infered typing. It's basically OCaml running on .net/mono. I've rewritten C# code in F#, and the latter is definitely much more concise than the former... Strong typing is actually quite nice too. For instance a small neat effect : it prevents any kind of null pointer exception, null being a type in itself. Though sometimes strong-typing gets in the way and I wish it had duck-typing...

That said Microsoft doesn't seem to advocate the use of F# for GUI... They still recommend using C#, or the ugly thing that has Basic in its name for doing so.

</comment><comment><USER18> Every functional language I have tried has given me a compelling reason not to use it. In most cases, it was a stupid reason that had nothing to do with it being functional. Some of them force you to sort your functions by call dependence (caller must be after callee). Most of them are woefully lacking in library and toolchain support - no bindings for essential APIs, no graphical debugger, no code completion. In the end, it proved easier to add functional features to languages which already had these things and had proved themselves free of fatal flaws, than to fix the flaws and add support to the functional languages people were promoting.

<comment><USER13> Indeed. To be basically useful in a commercial setting a language must have rock-solid bindings to a) a major GUI toolkit on all its supported platforms and b) the big 3 databases. This is why I have high hopes for F# - <USER2> industrial-grade OCaml with full access to the vast .NET libraries _and_ integration into one of the best IDEs around.

</comment></comment><comment><USER19> [http://enfranchisedmind.com/blog/2009/02/22/programming- does...](http://enfranchisedmind.com/blog/2009/02/22/programming-doesnt-suck- or-at-least-it-shouldnt/)

</comment><comment><USER20> Yeah, no two ways about, for average kinds of tasks, most commercial programmers just can't get it.

I did some (I thought) quite neat Clojure code to merge some data ranges in about 27 lines (versus a house programmer's effort of 1000 lines of c#). My solution was not received well, even though it could have fairly easily been translated into c#.

Sadly, if you get FP and the cool things it can do, it gets really painful to be somewhere people don't get it.

</comment><comment><USER21> It's caught on as far as I can tell. Nearly half my recent projects have been Haskell.

Sure, some people are still using Java, but who cares? There's no reason why _you_ can't use Haskell, OCaml, or F#.

<comment><USER22> Believe it or not, but java can be written functionally: you have to use an interface (and a few classes) to implement a list and you can use objects as functions... but it's not usually something people get into.

<comment><USER21> Why bother? Round hole, square peg. You will spend 99% of your time fighting against the language, instead of writing code.

<comment><USER23> Not only will you fight against the language, but the functional style code you produce will be awkward and unreadable by other Java programmers. If this doesn't matter because you are working alone, then why would you choose Java in the first place?

</comment></comment></comment></comment><comment><USER24> God save FP from the "mainstream". I know I sounds elitist but I honestly don't see how it would benefit FP to have lots of Java drones descending on it and taking it directionally into "simplifying database access" (for instance).

The reason I like FP is because it is "pure" and I enjoy the difference in the thought-model when programming. Plus I usually can get things done much faster. I think this is why most people enjoy FP in one way or the other. Why ruin that in the quest for popularity?

</comment><comment><USER25> To all the fellow FP fans - why spend so much time trying to convince nay- sayers that FP is great, that it makes code shorter, simpler, safer, more robust, more fun? They will not get it anyway, until they try it. And sadly, they won't try it. Let's just use FP to our advantage and crush the competition!

</comment><comment><USER26> Practical Common Lisp (<http://www.gigamonkeys.com/book/>) is a pretty good book, that covers these things. Accessible, practical material is definitely out there, but some kind of sea-change will have to occur before it goes "mainstream." I'm not sure it ever will, though, or if it even matters. As other commenters have noted, F# might be our Obi Wan here.

</comment><comment><USER27> Ever heard of Erlang? =)

It's getting pretty hot right now.

</comment><comment><USER28> because it's harder to maintain.

<comment><USER29> To find replacers you mean?

I certainly don't think the code itself is harder to maintain or change, quite the contrary, good functional code is more modular than object-oriented.

<comment><USER28> just anecdotal, could be a problem with something I'm doing or I could have just gotten luckier with OO than with F and encountered much better code in the former.</comment></comment></comment>


Java Primer for Python Developers - <AUTHOR> https://maxmautner.com/2019/09/12/java-primer-for-python-developers.html <comment><USER2> > The only thing I might add is that Java requires using an IDE.

> With Python I somehow managed to survive with Vim as my IDE.

> This is not possible with Java, I do not recommend even trying.

Well of course it is possible. When I wrote java actively ten years ago, I managed a 30kLOC code base with a text editor and ant on the terminal. However, wasn't using Dependency injection, unit tests or any quality endurance which is mentioned in the article ;-)

(another) Story time: For a recent scientific code (physics, written in CPP and Fortran), a professor decided to use Java as the glue language for code generation. So people set up their Eclipse environment just to edit this small java based toolkit. If you otherwise edit your code in vim et al, it is still a horror as it has been 15 years ago. The IDE required a minute to load on my decent core i7, SSD and 16GB RAM. It is powerful, but awfully slow. Luckily, they decided to reimplement that code in Python. That was kind of a game changer for the overall project.

<comment><AUTHOR> It is--of course--"possible" to code Java in Vim (that's how I did my job interview ;) )

I feel your pain though--in the time it takes Eclipse to open you might have solved your problem in Vim.</comment></comment>