81–90 of 138 posts
Also, if you want a brief overview of different paradigms you should check "Seven Languages in Seven Weeks" (https://pragprog.com/book/btlang/seven-languages-in-seven-we...)
Reading these replies just makes me sad. There's plenty of value in and plenty to learn from older technologies like Lisp, Scheme, Smalltalk, and Forth. Sure, there's a lot of hype around newer technologies. There's never a shortage of hype. But the glow around virtually all of them will fade, probably sooner rather than later. Ruby and Python are no longer considered hot and new, but not so long ago they were. Java…
As a sub-question, I would be interested if the answer was restricted to frontend frameworks (eg. Backbone/Ember/etc.) for 2015. Thanks in advance.
If you're into SASS, I'd check out: Susy: http://susy.oddbird.net/ Otherwise, if you're into the latest Javascript frameworks, I'd check out: Aura: http://aurajs.com/ Kraken: http://cferdinandi.github.io/kraken/ SkelJS: https://github.com/n33/skel If you're looking for something more "bootstrapish" but without all the "bootstrap" bloat, I'd look at some more modular frameworks like: Semantic UI: http://semantic-ui.co…
Decide and have clear what is the question, then look for the answer.
---
For the fun of learn, pick anything you can do and put some time of it. If you are like me, you will read some info about X and and if it pick you interest go ahead.
But without a direction, you will waste time. You will dismiss things that are good and double-focus in things that not..
----
"I am facing a lot of challenging (which ones?) data analytics and software development problems during the day (which ones?)"
"Data analytics (and his not-famous cousin reports)" is far more about re-shape and clean data than do cool algorithms. The last mille is the easy and the 909% (yep, 909%, not a typo!) is the hard, in opposite to normal development.
Having a clean, well defined schema/database/warehouse/etc is the thing here. Run your super-fancy mathy-thingy on it? Others have solved that!
Most likely, non-normal-dev will have a bigger impact on this kind of jobs, so not just focus in tech.. (and I don't drink the fallacy that your selection of tools not matter. But is also a mistake think that are the only thing that matter).
The Kernel language is small and simple, yet offers a huge contrast to how you would think about programming in most other languages - namely because other languages have reduced their model of computation to reduction.
Kernel is influenced by the Lisp family, but offers somewhat of a duality to it. In lisp, everything is passed implicitly reduced unless explicitly quoted, then they are passed verbatim. In Kernel, everything is passed verbatim unless explicitly evaluated - the callee then, has complete control over how something is evaulated, rather than the caller. (And consequently, it's trivial to simulate lisp's computational model in it)
Reduction then, is just a special case of a much more general computational model - passing arguments around. Other languages have coupled the idea of argument passing with reduction, such that they need to invent compiler hacks like macros or code generation when it turns out that reduction is not what they want. Or in some cases, we've created languages specifically for template-based programming, where we want to splice bits of code into an otherwise static block of text. Such templates are trivial to do in Kernel.
Another nice feature of Kernel is that of encapsulation types. One can define a new type which consists of a constructor function, eliminator function and a predicate to test for the type - and combined with the powerful information hiding that can be achieved through Kernel's environment model, one can implement sophisticated type systems using very few primitives, and without special compiler support.
As you probably know C++11 is already around and majority of compilers already support it. What most people don't know is that C++14 is ready to kick some ass too! It introduces for the first time in C++'s history functions as first class objects and allows you to pass them around as function parameters! I think this is really exciting and I also encourage as many people to take a look at this new and very promising developments of C++ language.
On the other hand, Apple's Swift looks promising too - functional elements, type inference, speed, good compiler and so on. Not to mention it's being used with tons of great frameworks Apple provides for iOS and OS X development. It sure doesn't hurt to take a look into it too.
All in all, it really is an exciting time for us developers. There are really tons of cool tools and languages that allow us to get things done at the speed never imagined before.
Now, we should also look back at the fundamentals and ask ourselves could we design, not only program? That's not the skill you can pickup in couple of days reading bunch of tutorials and forums about your next cool language. I think, learning how to think about particular problem and how to approach it is more important than barely know how to code the first solution that comes to your mind in the new ultra fancy language. Think about it...
I personally prefer Scala as I like strongly, statically typed languages, but I've played about with Clojure and it's very nice, too. A vast number of benefits come from having a rich immutable collections library.
Reading these replies just makes me sad. There's plenty of value in and plenty to learn from older technologies like Lisp, Scheme, Smalltalk, and Forth. Sure, there's a lot of hype around newer technologies. There's never a shortage of hype. But the glow around virtually all of them will fade, probably sooner rather than later. Ruby and Python are no longer considered hot and new, but not so long ago they were. Java…
It's definitely possible to learn things from those languages. But languages that are trendy today (at least from my experience in the London job market) - Clojure and Scala - are really amazing, too, and have a lot of interesting ideas about concurrency, immutable data structures, and functional programming. Scheme, when compared to Clojure, seems a bit outdated now IMHO, although its extremely simple, small core ma…
This is an unfortunate, but all too common a perspective, since most people who are exposed to Scheme are exposed to in in an academic environment where they only get to play with ancient, primitive Schemes such as MIT Scheme of SICP fame, and come away with an impression that Scheme is a quaint toy language that may be useful for pedagogy but probably nothing else.
Nothing could be further from the truth, if you consider the capabilities of the modern Schemes.
Git is not the final word in DVCSes... Take a look at Mercurial, in particular, the Mercurial Evolve feature. It's an innovative way to collaboratively polish commits. Imagine pull requests that could be rewritten with the history of the rewrites being easily accessible as you see them, well, evolve . Evolve is basically a way to record and use distributed meta-history of the editions of your commits. It's like a bee…
The problem is that in the open source world, most projects use Git and most active old projects using SVN or CVS are slowly moving to Git. Many people out there who greatly prefer Mercurial to Git admit to using Git much more than Mercurial due to the ecosystem. See: https://fuzz.me.uk/git-vs-hg/ From Eric Raymond: >git won the mindshare war. I regret this - I would have preferred Mercurial, but it too is not lookin…
Also, this whole popularity argument, if it were to be believed, could have killed Linux in favour of Windows or FreeBSD in favour of Linux. Just because something is popular doesn't mean that alternatives need to cease development or are not worthy of attention.
This thread started with a request for exciting new features. A certain degree of experimentality and non-popularity is in order.