Whether it is a side project or a professional one, what programming language and/or framework (web, gui, &c) do you plan to use for your next project, and why?
Because for 95% of my projects, personal and professional, thats the tool to solve it. I don't have to reinvent anything, or worry about gaping security holes common to web applications - i just need to work on the problem domain.
I can focus on good modeling and good front-end UI/UX. And there is flexibility in delivering desktop/mobile applications quickly, using what i've already built in rails.
As a one man band, I can't think of a better instrument to play.
Oh how I love Rails, the framework and language (Ruby) of developer happiness. But now working in AI, it's a Python game. This is maybe embarrassing to admit but I prefer having the Python pipeline, TensorFlow, numpy, etc. living on its own box, exposing inference as an api, so I can keep developing in Rails and its supporting ecosystem (background processing, push notifications, etc.) as the main app handling everything else.
I mean, I get it - for a personal project, I did exactly what you just described, wrote the web app in rails and wrote some scikit-learn stuff with python. I did this mainly because I like rails, I like python for ML stuff, and I didn't want to have to learn Django to get a prototype working.
But assuming you were willing to take a small hit/make a small investment in a new technology, do you think it might be a little better to have it all in python, and use Django? Or is the separation similar enough that it doesn't really make much of a difference (i.e., you'd be calling the ML stuff through an api anyway, an your web app would be pretty separate from your ML service, so the only real benefit to Django vs Rails is one language for everything, which I'm inclined to think isn't that big a deal).
I've moved more heavily into Python lately because of data analysis, ML, numpy, all that, and I am enjoying it a lot. I find python very nice to write in, even though I like Ruby and Rails a lot. Python looks good on the page, and has that clarity I like in ruby and rails, and of course the scientific programming world isn't really a ruby one, python is far, far more prevalent. So I've been thinking of taking the plunge and learning Django, but I'm not completely convinced it's really necessary, since you can do what you just described here...
Oh also, (sorry, this is a very scattered post), would you mind sharing some of the technical information about what tech you used to create the api for your python side?
Ok, so I'm going to bite. I'm using Django for my company's website[1], and while I think it's hands-down the best framework for Python, I must admit to having felt some envy when I investigated what all the fuss on Rails was all about.
I think Rails' controller concepts are cleaner, and its way of handling forms is simpler and more direct (granted, with more sugar or magic, which some have a problem with -- not me).
Why would that be embarrassing? You've effectively created your own private AI microservice (to use the buzzword du jour) and consumed it in your favorite webapp stack. Sounds pretty smart to me.
There are so many jobs out there in rails / ruby. I really want to learn it, but the tutorials I've seen teach you how to generate a blog engine. I want some real world examples and tutorials, where's the best place to start?
:) For me, I really got a lot of value out of railscasts.com. I watched all of them like people watch their favorite TV shows. Helped me see the world through rails developer eyes.
I used to pay for a subscription to Railscasts, and it was money well spent. It's too bad that Ryan stopped making new videos.
Railscasts was awesome. In particular, I really loved the ASCIIcast feature on each video. I can't say enough about how helpful that site was in terms of helping me learn Rails.
> There are so many jobs out there in rails / ruby.
Just today, another commenter [1] said that...
The job market for Rails devs seems to be pretty dry.
Many Rails devs I know, including myself, do not get even
10% of Rails job offers anymore, as it used to be until a
couple of years ago.
ok, maybe "so many" is a little bit of an exaggeration. WeWorkRemotely.com lists 72 programming jobs at the moment, and 16 of those mention ruby and/or rails.
Tried getting a job to move to Rails development once. I have 5+ years of PHP and MVC frameworks experience. They said I can't get the job for two reasons:
1. If they tried hiring me as a mid-level Rails dev, I'd be too inexperienced in Rails
2. If they tried hiring me as a staring Rails dev, I'd be too underpaid
So apparently, my past web dev skills are non-transferrable to some companies that hire web developers. Yikes.
elixir is awesome, and it's the language i use on my personal projects. But it's still pretty immature and if you're writing a web application, rails will get you further, quicker.
With rails when i'm writing some new code quite often i'll open pry and experiment. %w!bob tom harry!.<tab><tab> gives me all the things I can do on this array. So maybe I'd do %w!bob tom harry!.sort
If i'm in iex (the elixir equivalent REPL) I have no such help! first, I can't use %w! to define an array, and secondly You can't call things like that. The equivalent is
> "first, I can't use %w! to define an array, and secondly You can't call things like that."
The second part is a pretty fundamental language difference but you can use sigils to handle the first part. E.g., to generate word lists use ~w like so:
~w(bob tom harry)
If you don't want to use parens, you could use pointy brackets, braces, pipes or a few other delimiters instead.
1) I generally prefer Ruby's syntax over Python's (I would miss blocks for sure)
2) Rail's ecosystem seems larger than Django's, but that could just me being more familiar with it
3) There seem to be a lot more Rails jobs than Django ones
Django would make more sense for a business that uses python for other things, though.
Not OP but django is huge and the dependency chain is crazy for me its just way more than i need and doesn't solve a problem that i can already solve with more light weight frameworks.
I have know django developers who were great in django but never got their heads around python beyond the framework.
Maybe things have changed since the last time i poked at it.
This seems off. Not the correlation to languages (although I'm pretty sure that I've contributed my fair share of negative commit messages to Rails projects), but the fact that only about 20% of commit messages are deemed neutral. I would expect at least 50% there, since most times the commit message just neutrally describes what has changed.
This is exactly how i feel about flask and prior to flask turbogears. Stick with what you know until it doesn't solve the problems in satisfactory way.
true, but I could have just stuck with PHP then I feel. But rails represented more than just slinging code - it represented professionalism. Doing things well. Maintainability, and above all else developer happiness.
With PHP, building an online store was possible for me. With Rails, it became obvious.
Always be willing to upgrade - but don't hastily discard something useful for something new either.
Not supposed to be a short term project, though. Currently working on extending inth-oauth with openid support. I'm only really able to work on the fringes of this idea, though, since:
* Rocket itself is currently on Hyper v0.10, while v0.11 became async. This means various libraries around it are adapting async while Rocket itself won't for some time. Thus, I'm working on the fringes getting them to async.
* Async itself is in flux, because generators should be entering nightly any day now. When that happens having async/await macros available will make a huge difference.
Generally though I do really see Rocket + Rust in general becoming a huge deal in webdev. I've used Rust for so many C++ equivalent roles because of its safety guarantees, and they make development so much faster when you aren't dealing with undefined behavior cropping up in the corners you have to dig through to find. Additionally, the larger a project gets, the more valuable static typing is. Rust even pushes you towards best practices further by pressuring static dispatch and lock-free sharing of data.
How does that stack fare for building REST/GraphQL APIs? I've been meaning to play with Rust, but I'm not sure if using it for a Web project will be worth the trouble.
It's incredibly productive, you get the benefits of microservices with the development and deployment style of monoliths thanks to umbrella apps and there's not a single performance based concern I can think of that it can't handle.
Plus it simplifies infrastructure significantly by removing the need for much outside of Postgres.
I would love to use Elixir and Phoenix for my next personal projects, but I would not use it at work.
Elixir and Phoenix developers are much more expensive and scarce than Rails ones.
I would only start to use Elixir and Phoenix in my company if we were fully staffed and the rest of developers agreed on putting some extra effort (mostly during their time) to learn the new system.
How are you planning to deploy it? Getting the benefits from Elixir/Phoenix seems to require much more old fashioned thinking: long-lived, mutable servers with direct interconnects, so none of that immutable infrastructure, or platform-as-service stuff.
Not a perfect choice of terms I freely admit. In my own experience, I last used non-virtual, mutable, long-lived servers over 8 years ago. Since then it's been a progression further away from that style: PaaS, immutable infrastructure, Heroku, and currently a mix of AWS Lambda and Docker.
You can deploy it exactly the same way as anything else, it's just a matter of being willing to sacrifice some of the features if necessary. You don't necessarily even need each of the features on each project so it's entirely reasonable to deploy exactly like you would anything else.
There's a Redis adapter for Phoenix channels that you can use in environments like Heroku where clustering might not be an option.
If you want to use built in Mnesia database on an immutable or cluster, attach block storage and configure it to store to that disk so you can remount when you deploy your immutable image.
Hot reloading is the only one where you NEED mutable servers.
Your needs might be different from mine, but I'm using Gatling for push-to-deploy on a couple of production Elixir apps. It includes the ability to do hot upgrades. Deployment couldn't be much easier than this.
Haskell, unless I have a good reason to use something else. An example of a good reason was a recent project which made heavy use of s-expressions, so I learned Racket to do that and it works reasonably well (required quite a lot of optimisation for a particular loop though!).
As for "frameworks", I find JSON over stdin/stdout to do almost everything I need (Haskell's aeson package is good for this; I might try learning lenses too next time). I also make extensive use of env vars to pass options/config into programs, since I find their semantics (key/value pairs, globally readable, inheritable by child processes, overridable for child processes) more friendy than commandline arguments. Their only downside is being mutable, but that's easy enough to avoid in one's own code.
I also use Nix to manage all building, dependencies, etc. since it's trivial to get code written in many languages to play nicely together (my current project uses Haskell, Bash, Racket, Python, ML and Isabelle). Nix's "Hydra" build server is nice enough for continuous integration, although it's admittedly tricky to set up (it doesn't have proper versions; you need to find a git revision which works :( ).
Static/dynamic analysis of code, theorem proving, automated reasoning.
Bash is mostly for gluing things together; it's (almost?) all in the form of Nix derivations, and mostly just pipes things around (lots of calls to `jq`).
It's difficult, but worth it. Lenses are super cool. They also play well with Aeson. There's a package lens-aeson that has a bunch of useful stuff. You can actually operate directly on Text values and treat them as JSON structures.
...totally made all those up, but by the time I get around to it they'll all probably exist, right? Point being, it is both alarming and overwhelming to me the sheer number of available frameworks and languages that all attempt to solve the same things. Even when I dedicate myself to learning whatever the "latest thing" is, it's only a matter of months until I feel behind the curve.
I'll stick with C# on the back-end and React/ES6 on the front until something compellingly better comes along. The reasons NOT to use .NET on personal projects (especially the $ factor) are continually declining, and there's really nothing I've learned about that stack that doesn't readily translate to whatever other languages I've encountered thus far (Python, Ruby, Rust, Go, etc).
The only thing I feel like I'm missing out on at times are algebraic data-types, so I guess I'll give a nod to Haskell on that front.
One could say that we're professional learners, and that learning things doesn't actually progress us in our career paths, but that our ability to learn -- the efficiency and rate at which we learn -- is the thing we get paid for.
There's certainly some aspect of that, but there's also the need to create business impact, and in my experience that is the more valuable skill to maintain. It's all connected, though, naturally...
I've used C# for a few years and just started using it professionally this year. But never have used it for web dev. Is the .NET Entity Framework what is recommended today? What are some things I have to be aware of when setting up a web server coming from LAMP and MERN stacks?
I'm still finding that making the actual HTML part in Go is a bit frustrating. Template funcs have not become widely shared and people seem to deeply entangle them with their own project, and there's a lack of i18n and l10n too.
But... most of what I write lives with little to no maintenance, and this is a productive path to a very stable and easy to maintain code base that with locally vendored dependencies checked-in will continue to be stable over very many years.
I wrote a Go API some 5 years ago that has required virtually no changes in all that time (I've rebuilt it with every version of Go and only the 1.0 to 1.1 had a few dependency changes - which were trivial updates).
The benefits for me, hugely outweigh the negatives of not having more tooling for the web side (the API stuff is wonderful already).
For backend I'd surely use Elixir/Phoenix, that's what I've used in the last 2 years, after ~9 years of Ruby/Rails. Elixir and Phoenix are fast to bootstrap, easy to use and deploy, even for complex scenarios (background jobs, websockets, key-value store, etc). Even for quick prototypes, I find Elixir/Phoenix a lot simpler than Ruby/Rails.
For frontend, thus JS, I'd use Vuejs. I switched to it after some year with React. It's a perfect compromise between React and Angular.
I'm going to do most of my logic in Cobol. I'll make the front end with ActionScript & Adobe Flash. I will then call myself an expert & charge around $500/hr for migrating software services.
I'm going to use Elixir and PostgreSQL for my next project, which is an algorithmic trading platform. The two main reasons is I want to learn more Elixir (I've done a few libraries and some other work with it but not a lot) and also the OTP's supervisors will keep things up and running even during a crash. This will be nothing more than an OTP application so no front end available. I may end up making a front end so I can track everything visually and if I do I would probably learn Angular 4, or maybe go back to Elm.
Docutils allows deep customization of source text, programmatically. There's a lot of work needed to bring it to the next level, but the potential is huge. There can be beautiful LaTeX PDF documents and improved HTML output.
Bulma is already a great flexbox-based framework: http://bulma.io. I threw out two huge framework (bootstrap 4 and mdbootstrap pro) to use this. The markup is far simpler, the spacing is grand, and the feature:size ratio is perfect. Highly recommended.
I'm not sure if this is because I'm using a Chromebook, but the HTTPS link to Bulma both fails certificate validation and fails to load CSS. http://bulma.io works fine.
Edit: and it looks beautiful! Thanks for the pointer!
Definitely Haskell, with GHCJS and reflex-frp for the frontend.
I've been using Haskell for most of my personal projects for a while and, over the last year or so, I've been using it at work. The overall experience is incredible. It's hard to isolate exactly why it's so great, and there are certainly some concrete annoyances (tooling and compile times, mostly), but the end result is still unquestionably the best programming experience I've had with any system.
It did take more effort up-front than other languages I'd used. There's still a lot of incidental complexity with bad error messages and tooling that's hard to setup and understand—although it's definitely improved over the last few years. And it did take significant effort to learn, largely because it's so different from every other language I know. But once I got over the initial hump it's been smooth sailing, and I'm always happy to spend some up-front O(1) effort for a long-term reward!
The codebase at work—written by a small team with different backgrounds and levels of software engineering experience, sometimes under tight deadlines—is still largely a pleasure to read and refactor. I consistently leave code in a better state than I found it, not because I am particularly disciplined but because it is so easy.
I also tend to work on my personal projects on a very on-and-off basis—more off than on, most of the time. I've found my Haskell projects to be much easier to pick up months or even years later as compared to my projects in other languages (largely JavaScript as well as Java, Python, elisp and who knows what else).
I've been working on whatever interests me, which tends to relate to programming languages. My biggest on-and-off project, for example, is a tool that compares source code based on parse trees.
My main advice is just to jump into it, and to distinguish problems that you should try to solve on your own to learn faster from purely incidental problems that aren't worth your time. (Conceptual questions and understanding abstractions falls into the first camp; dependency issues and bad error messages in the second.) Especially with the second sort of problem, you can always get help on #haskell IRC, /r/haskell or StackOverflow.
After some on and off experimentation for quite I while, I finally started a side project using Clojure(Script) in the backend, frontend and the data crunching workers.
So far it is more about learning new things and a different approach to problem solving than about productivity.
If productivity and design is crucial and/or I need to quickly get out something I currently would go with either Pyramid, Flask or Django depending on the requirements. Not because I think Python or these frameworks are superior to all others, but because I value experience higher than technology.
Web - Flask / Postgresql / Vuejs (i can't stand complicated js build chains when 99% of the work i do is sever rendered with only small parts needs js).
Standard Small Business apps - python / pyside
Automations and sysadmin - python
Fun/Learning - everything. I am constantly playing with java, c#, go, whatever made me feel tingly most recently but i rarely move from learning/fun to using it in production as the above stacks just work and i am very proficient in them. Something to be said about getting a problem solved fast and easy.
I've had good luck with React -- but only when using in a smart way. When I develop my reporting software I just use Flask as you do, and even jQuery for simplicity: usually it's just some small modification to the DOM that I don't even need jQuery for, but why not?
Ruby on Rails if it's something that doesn't demand top-of-the-line performance. It easily makes me the most productive writing backend code/APIs and it's not really close -- so many problems that are just solved, sane conventions, etc.
Elixir/Phoenix if I need blazing speed. It's younger and a bit more of a wild west but the speed is incredible.
React for the frontend (if it's anything more than basic CRUD). Regardless, webpack for frontend assets -- I'm never going back to sprockets.
I plan to repurpose old-ish boards with MIPS/ARM SoCs (e.g., AR7240) for various network security purposes. For the C part I have a set of daemons planned and partially implemented which will provide basic functionality without mixing in too much policy/role specific stuff, as well as an IPC library for those daemons. Lua will be used for the test harness and for wiring the functionality provided by the daemons together based on the role of the specific device. POSIX sh for things like execve shims and glue. Everything running on top of a small Linux system. FreeBSD would be nice, but I've had some mixed results with support for it on some SoCs and I want it to be as painless as possible.
Purely a hobby project ATM. I have a couple of boards lying around and I like the design constraints; it's nice to write code for something that's 400MHz, 8MB ROM, 32MB RAM and the size of a match box. Some include removable PSUs, but can also be powered with Li-Po packs &c. Most of them have Ethernet and USB, some WiFi.
Elixir and Phoenix. I've been working in Elixir full-time for about 2-3 months (I rewrote a Rails app at my company), and I feel like I can't go back to Ruby.
I want to experiment with using GraphQL, and mapping the response to props for my React components. It seems like it has the potential to be a lot cleaner than a traditional JSON REST endpoint.
I know some friends who're excited about elm, and that also seems like it would fit nicely with an Elixir backend, so that's on my list of tech to try out.
In my free time, I have some ideas for some more OTP-heavy distributed Elixir OSS.
My docker-compose always has these three containers: Node (for server side rendering), Python (for APIs) and PostgreSQL.
For the frontend, I use React + Redux + React-Router + Redux Sagas (I like starting with a modified version of ReactGo: https://github.com/reactGo/reactGo).
For the API, I use Flask + SQLAlchemy.
I've been thinking about replacing Python with something more strictly typed (Python 3's hint are a good step, but not enough IMO). However, SQLAlchemy is so great I can't imagine developing without it :)
This is what I've been experimenting with. How are you getting along with rendering React on the server from Python? react-python seems cool but it seems like I'm going to have to do some extra legwork to render a whole redux app rather than just passing props to a component.
Or are you serving up the user-facing pages from Node?
Elixir/Phoenix is just delightful, and I'm feeling really comfortable in both. Front-end is my weakness, so probably something popular like React would be good.
ES6 for a React frontend (probably with some gradual migration to TypeScript where possible), either Ruby/Grape/ROM or Kotlin/Dropwizard/Kwery for the backend.
I tried, I legit tried, to go with TypeScript on the backend. But SQL is a continual sticking point in Node; Active Record is bad-and-wrong (immutability removes such classes of failure as to be a no-brainer) so Sequelize has minimal value to me and TypeORM, which definitely has a more reasonable approach with its data mapper design (though it then also commits the sin of decorating your entities), doesn't...seem to...work very well yet? It's early for them, so not throwing any shade. The lower-level libraries will result in me basically reinventing the world for them, and...well...no. Ruby and ROM are as close to doing-it-right as I know, but I think I want a type system to catch my stupid mistakes and Kwery, while immature, does work very well and doesn't rely on object metadata or annotation in order to do its thing.
Backend: Scala, Play framework, Akka, Postgres - rock solid type safety, scalable out of the box, mature but modern framework and the best database money can't buy. Frontend - Typescript/Angular/Material - all included framework with typescript's static typing works well from small to large projects.
Good luck :) I love the language, but you'll need some perseverance to learn the more interesting parts like lifetimes and the borrow checker. I can recommend the book on rust-lang.org!
I will definitely be taking a read. I've tried to get into Rust before and it was a lot to be getting into (especially since I was also trying to learn Go at the time.)
But now, almost a year later, I think I finally have a pretty good handle on Go, so I think it's time to break out the Rust again.
I’m currently using Rust to make a program to manage my dotfile configuration/templating. I’m having fun, but it’s hard (and I’m porting something from Ruby that has a long history).
Personal
- Elixir/Phoenix for a web project (just an excuse to mess with these technologies)
- Racket to explore an idea for a large rule-based application for higher ed
- OCaml to try out its programming language design set
- Swift to make an iOS game with my daughter
Professional
- Python3 to rewrite a moderate-sized batch application with a lot of custom rules
- Java/Spring to rewrite an internally-used web app
The thing I hate most about Flask is how hard it makes testing. There's too much global state and stuff you have to mock/hack. A little too lightweight for my taste.
I'm using Pyramid and it's decent. A little less convention-oriented than Rails but still, nice.
F# and websharper for web projects. Because I passionately hate JS and I think 2-Lang solutions like node+Elm just seems like a hack in comparison to the 1-Lang solution.
For non-web: either, F#, C# or Rust depending on what it's about.
Django, started learning it in may and loved it so far. I have a lot of experience with PHP frameworks such as Laravel and the Yii platform and NodeJS + React + Redux. So I wanted to broaden my skillset :)
I'm using Lua whenever possible for side projects. It's familiar enough syntax-wise that it's easy to transition to it and get something done but weird enough that I don't feel like I'm still at work. I even kind of like the infamous array indexing and nonsensical length function because they don't behave quite like I'm used to.
- relational language, kanren based probably, first goal would be instantiate all struct from a c codebase
- rust on an esp controller, or as a lisp implementation language
- lua as embedded scripting for dillo
- clojure to try to design a more concurrent lazy reactive graphical system. Totally because it's been since forever that I wanted to have something more lively and that I knew back and forth.
Because Clojure as a language really spoils you, it's more concise and quick for prototyping than any other tool I've tried. And Reagent or Om build lightning fast interfaces.
Clojure with ring/compojure and datomic, frontend in Clojurescript with rum. You have to roll your own auth* though, but with the help of some libraries it wasn't an issue.
I searched before posting, but my next application will be Perl-based. I use CGI::Application as a framework for the website, along with a simple queuing system written as a wrapper around Redis for handling async & background jobs.
(Background jobs in my case mostly seem to be responding to webhooks, sending out emails, etc.)
Hey you have some nice projects and by far the cleanest Perl code I've ever seen! I wonder what you think about Perl 6, as that's a language I'm kind-of partial to, but the learning curve seem to be a bit too curvy?
I'm a huge fan of Perl, and I've been playing around with Perl 6. The transition had been pretty smooth, and other than a few minor syntax changes (e.g. "." for method calls instead of "->") it feels the same.
Having said that, there is a lot more to Perl 6 than what comes baked into Perl 5.
The transition is a lot more like C to C++, where you could just use a C subset and be immediately productive.
Perl 6 has given me basically all the things I wanted changed in Perl 5 (function signatures, everything is an object, built in REPL) plus a whole bunch of stuff I didn't know I wanted but now love (gradual typing, crazy powerful type system, amazing out of box CLI argument parsing).
With Inline::Perl5 you also have access to all of CPAN.
Performance isn't quite there yet, but for the stuff I use it for (one off scripts, reports, personal CLI tools) it's been great.
Currently using, and would use again: Orleans on .NET Core.
Orleans is a virtual actor framework, similar to Akka in Scala.
For anyone unfamiliar, it's basically distributed OOP built into the runtime. You instantiate a User class, and that class instance will exist somewhere in your cluster, but you can access it like a regular class anywhere in code. You could then have a Company class on another node in the cluster, and they can interface seamlessly with each other without any networking code -- just as if they were running on the same machine. Adding capacity is as simple as spinning up more app servers, and because of the way Orleans handles state and garbage collection, you've basically got a distributed cache of all your recently accessed objects, so next time you access them there may not be a need to query the database.
VHDL and Rust. Probably a bit of Verilog too if I need a core someone has written in that...
Rust because I want to learn it, VHDL because I know it reasonably well and need more practice. Also I've got a nice little FPGA dev board, I should get some more use out of the thing. (Digilent Nexys4 DDR).
I was quite happy to discover how easily you can use Ecto to integrate with an existing database. I had to override a few things (e.g. the primary key isn't called "id") but it really worked quite smoothly.
I'm looking at the world of proof assistants and SMT solvers because I have a very hard constraint satisfaction problem, and I'm hitting the limits of what I can do with a backtracking binary search. This is a new area for me, and it seems like most of the work in this area is being done by academics. I've been reading up on Coq, Lean, Rosette, Z3 and Prolog CLP/FD, but I still don't have a good mental model for this space, so I'm not even sure I've identified the right potential tools for the job.
Please tell me more about this task! Regarding Prolog and CLP(FD), I recommend asking on comp.lang.prolog or Stackoverflow for more information. Chances are high that someone will be able to help.
Unless I have some external requirement, I write in Clojure. I usually target Postgres as a data store (and use the excellent HoneySQL library for Clojure to do so). I've been liking the productivity of compojure-api, and I don't see a reason to abandon it now that 2.0 is almost out and has major speed ups. It's very hard to pass up the JVM ecosystem for libraries and Clojure let's me abuse those with minimal fuss.
I think we might be of the PHP age :P when it was good enough to actually use it, but still widespread enough (e.g. no alternatives) that it was necessarily the first thing that you did.
Same here, doing frontend stuff in Elm. After a couple of sideprojects or smaller parts of production env with this stack I want to make a full project
C++, for a side project. I want to do tagging really fast and so far, out of PostgreSQL, every graph DB I could get my hands on and Redis, I haven't been able to find one that performs as well as I like. So far my experiments in C++ have shown that it's possible to do it and do it faster than anything else, at least for my particular use case.
scheme is a great learning tool. its kinda of a poor engineering tool. but if you spend enough time I promise it will give you a lot of leverage when looking at problems somewhere else
Currently starting to build a native macOS/iOS/watchOS productivity app, therefore picking up Swift.
I'm coming from web development - and feel a bit stuck on how to layout things with Xcode / Swift. I'm not convinced by the graphical way to build interfaces provided by Interface Builder / Storyboards, as they feel quite limited in terms of precise control, dynamic layout, no duplication and use with VCS.
Optimally there would be something like React to build interfaces declaratively.
Does anyone have some insight into this topic?
(Also: why are variable declarations so implicit in Swift? When importing a package all its exported variables are avaliable within the file, making code really hard to read in my opinion.)
You can build your UI programmatically and not touch storyboards/xibs. A lot of people do this and I am slowly moving away from IB myself. This library has been recommended for doing autolayout:
Sure...using forms-mode to search, add and update information in a postgres db.
I would like to find a way for everyone to use org-mode but we were running into too many merge conflicts.
I just learned about mmm-mode (https://github.com/purcell/mmm-mode) but I haven't really dug into it to see if this could be the bridge between Org-mode + forms-mode.
Interesting, I hadn't thought of using forms-mode to do that. It doesn't seem to support it out of the box – are you writing other functions to dump the results of a postgres query into a file, and then using forms-mode to edit that?
Editing and entering structured data is still one of the most annoying tasks I do, and I still don't have a good solution to it.
I'm using Nim for a tiny personal project. I'm really liking the language so far. The compiler is still rough around the edges, but it is fast and I prefer the syntax to just about anything else I've ever used (except Clojure).
Whatever on backend + rendering all views there, plus unpolyjs for animations https://unpoly.com/ . This way the website should work without javascript!
Love the combination of Serverless and AWS, setup and deploy a full environment with Lambda, API gateway, Dynamo, Elasticsearch, SES with one command. All of it already on a CDN and fully scalable.
Web2py with a "normal" front-end, possibly some VueJS sprinkled in. Still haven't found anything as easy as Web2py to define my models/tables, built-in user auth, and get CRUD up super fast.
Lately I've been doing all my personal coding in C and/or scheme (guile). It's a fun stack and I love the "timelessness" of both languages -- code examples from books written in the 80's, or old libraries, still work (mostly) as-is.
For server stuff in production, once I went Elixir/Erlang I haven't looked back. Just blows anything else I'd used out of the water (in terms of productivity, performance, stability, and... FUN -- deployment is a bit of a bitch).
I'd also love to play more with Julia and Idris at some point.
Some computations with sparse matrices are better expressed in the M-code, but the bulk of the image processing work is done by standalone programs written in C, piped together by a shell script.
Android for a couple little things. A web project with vanilla Go, PostgreSQL, and vanilla JavaScript (because the frameworks lead people astray). Probably Processing for some experiments.
Most probably I will prototype a small CRUD app with Gin and Gorm to have a feeling of it. Anybody has gone this path already and would recommend a better tech stack based on Golang?
Golang. The combination of CSP, interfaces and great tooling are super fun to program with. Having more fun doing side projects with it than I have in years.
Scala. The project I wrote (Python) sends data to a Scala backend the CTO wrote, so I need to pick up Scala to gradually take it from him.
The rest of the team has been writing Scala for other projects (and Python for the ones I'm working on).
By the way, if anyone here is in Algiers, Algeria.. Get in touch, we're hiring (mostly ML but we're open to technically and humanly interesting people).
.NET MVC. I know it well, it has a lot of stuff built in and I absolutely love the ecosystem.
Coupled with Azure, I expect we'll have a production grade system in months.
The one thing I haven't nailed down is how to handle business rules - I might finally use a BRE as the project fits that need well, but I'm worried about those since I've never used one.
Clojure and Clojurescript. Clojure is already part of our stack and after working in it, I find it hard to work in any other language, especially OOP ones because of their syntax, unnecessary wordiness, and needless abstractions. I have yet to find a simpler language. I also have yet to find a more powerful language.
Besides that, I sort of want to go as minimalist as possible on the front end. I went clean for a while, relying on just jquery and CSS and it felt great, after all this time spent on Bootstrap. It just offers me so much control and customization to be free of frameworks sometimes.
Swift on the server: fast, typed and expressive like Python/Ruby
Postgres: the world's best open source Db no explanation needed
REdis : ranking systems and all
Elm: Seems easier to get shit done with, coming from an iOS backend...React/Ember are confusing
Working on a side project with lofty goals - project domain is personal financial management. Phoenix/Elixir on the backend and ReactJS frontend. OTP is too sweet to ignore.Not decided on database. Currently using Postgres. May change to CockroachDB.
it's funny, I have an adverse feeling to this question, I always think: "oh crap, I have to choose what I will hate fo the the foreseeable future". I really think we spend too much time with our tool, and we come to hating them.
Currently my favorite stack using my two favorite languages and I see no reason to change it; the only exception would be when the client wants a prototype ASAP, then I'll probably use Django.
Vue.js -- Tornado (python) -- postgresql. Deployed on Digital Ocean. For the vast majority of client projects I do, that's the sweet spot in terms of cost / effort / maturity / performance.
D3 and Node. I love how easy it is to create something interactive and beautiful with D3. And I feel like I've barely scratched the surface with all the built-in tools I have left to learn.
I can't wait for Jai to be released, both figuratively and literally. It's most likely going to be another year or two. In the meantime, I'm going to use Nim for some experiments in desktop application GUI development.
It comes with a blazing fast build system with dependency management. I've found it so easy to build golang projects or use them as a library. And the single binary for all platforms makes distribution easy.
The decision to keep the language simple along with bundling a great standard library reduced my learning curve.
I've been using Meteor with Blaze and mongodb for the last couple years for various small side projects and prototypes. I think it's a great way to get going fast and still works well at a reasonable scale. Plus, the reactive data loading is neat.
I will be starting a new project soon though, and I'm thinking of trying React, Apollo, GraphQL, Sequelize and MySQL.
It is. If you're looking for a web framework with statically typed language and don't want to deal with this monstrosity they call spring then Play has little competition. While basic stuff is easy, you can do more than just basic stuff since it's a full featured web framework. Some benchmarks: https://gist.github.com/schmitch/2ca3359bc34560c6063d0b00eb0...
This is my answer as well. The more projects and teams I work on, the less I'm willing to tie myself to any one language or framework. It's bitten me too many times in the past. Give me the spec, show me what the team I'm working with knows, then we can decide.
"Django is a great fit for any web application," becomes "Patch Django or spin up additional services with a new communication layer for web sockets?"
"Python is fast to develop in, and it will always be fast enough when running," becomes "It's not fast enough, and we don't have expertise to write the C extensions."
"Ansible is awesome," becomes "Salt fits our security needs."
"Angular all the things!" And we all saw where that one went.
For all I know, I'll be writing an Elm application in Electron. I hope not, but stranger things have happened.
For front end, Vue.js. It is what angular 2 should have been in my humble opinion. Any time anything changes in angular or react, both recalculate how the entire application state should be (although there are some workarounds). Vue, on the other hand keeps track of exactly how parts are connected so when one part changes, only relevant sections are updated. When compared to angular 1, the difference is night and day. I added Vue to Amy current app on a page with too many watchers and it worked miracles. I will definitely be using it in the future.
Because for 95% of my projects, personal and professional, thats the tool to solve it. I don't have to reinvent anything, or worry about gaping security holes common to web applications - i just need to work on the problem domain.
I can focus on good modeling and good front-end UI/UX. And there is flexibility in delivering desktop/mobile applications quickly, using what i've already built in rails.
As a one man band, I can't think of a better instrument to play.