From Rails to Clojure, Then to Java, Then Back to Rails

https://engineering-management.space/post/from-rails-to-clojure-to-java-to-rails/

by donbonifacio • 8 years ago

195 153 8 years ago

tcopeland• 8 years ago

In the "things learned from Ruby" section:

  Focus on strong object oriented programming

What I've learned from Ruby is to favor functional programming concepts - minimize side effects, isolate state mutation, etc. Ruby is definitely OO, but when my Ruby code is more functional it's less buggy, easier to understand and move around, and generally less convoluted.

dzuc• 8 years ago

Like Gary Bernhardt's notion of a "Functional Core, Imperative Shell" — https://www.destroyallsoftware.com/screencasts/catalog/funct...

faitswulff2• 8 years ago

Damn, I knew I got this idea from somewhere, I just totally forgot where. Thanks for posting this link - I'll have to rewatch it.

always_good• 8 years ago

I watched that video in my earlier 20s and it changed how I wrote code.

yxhuvud5• 8 years ago

As someone stated, good OO and good functional is approaching the same goal from different sides. Your code being functional doesn't really make it less OO.

joncampbelldev2• 8 years ago

Except if you're using immutable data, pure functions and explicit state there's a lot less room for OO which (as presented by ruby, java etc) involves mutable data accessed/changed via methods that conceal their state.

bitwize• 8 years ago

I've learned to think of objects as not exactly monadic, but monad-like in their pattern of use: whenever there's a bit of state that I need to track and isolate from all other state in the system, wrap that in a class. The allowable state transitions then become methods.

yxhuvud5• 8 years ago

Right, and most of the times, if state have different life times, then it should be in different classes.

blunte5• 8 years ago

Ruby used functionally is great, but it takes an already time-inefficient language and amplifies that weakness (lots of creating new collections and returning them, whereas normally in Ruby you would modify elements within the collection).

mullsork2• 8 years ago

Isn’t there something called LazyEnumerator that deals with this? In terms of chained .map at least

_diyu• 8 years ago

I've always had better luck restricting FP to using things like map, reduce, filter, (etc) inside methods as an implementation detail, but having the structure of the app use OOP.

scruple• 8 years ago

This is where I've landed when writing Ruby code, as well, and it's served me really well.

pjmlp4• 8 years ago

Incidently that is how FP in done in Smalltalk as well.

All those methods, and reactive patterns (Observer and such) were already present in Smalltalk-80.

dogweather2• 8 years ago

Yes - Ruby makes it easy.

I'm run into the downside, though, that Ruby isn't optimized for immutable operations - tons of object instances created. I've needed to 'pythonize' my Ruby code in the worst cases - using mutable functions to dramatically reduce memory usage.

cutler12• 8 years ago

Can you say more about this Pythonisation process? How is Python any better at immutable operations? Ruby and Python are both OO languages which can be used in a procedural style. Hell, you can write a whole app in Ruby without creating a single class if you so choose.

tonyedgecombe2• 8 years ago

Another thing I’m getting is that the new kids won’t like rails, and it’s being harder to hire.

I'm surprised by this, to me the language used would be a long way down the list when evaluating an employer.

Jacqued• 8 years ago

Surprising, for me it's one of the top criteria. The languages I'm using are shaping my process of thought, like when I'm speaking a different natural language, and some are more enjoyable than others to "think" in.

Besides, some languages give you vastly different career prospects (industries you can work in, salaries/rates, environment, etc.)

stevenwoo3• 8 years ago

Judging by listings in the month jobs posting, the vast majority of hiring companies won't look at you if you don't have immediate and long experience with their current tech stack.

jcadam6• 8 years ago

Back in my late 20s, I got stuck on maintaining a legacy software system written in Ada95 (I was unemployed in 2008 and it was the only work I could find).

When that job went away, I thought I could get a job using something more modern. However, the only job I was able to land was a new development project in Ada2005 (actually it was a port from SPARC to x64 and a partial rewrite of the same legacy application I had been maintaining for 3 years).

It took me forever to find a company that would "take a chance" on me - which is when I started working with Java.

That whole experience taught me that I always need to have side projects going so I have actual work samples to show potential employers.

derrekl• 8 years ago

While I'd agree with you as an entry level candidate, with experienced people, I've found the language is often the most important thing on the list. Often above salary. I would say it is more commonly number one than any other factor. I only know of a few programmers who have shifted through more than 2 languages in their careers (20+ year type careers). I don't have brilliant insight as to why. Perhaps the fear of starting at ground zero? Imposter syndrome? Feeling of throwing your past experience down the drain?

nitrogen• 8 years ago

Interesting. I've used at least half a dozen languages in my career of ~15 years. Apart from a few categories of language I avoid, I'm much more interested in the working domain, team dynamics, and quality of life.

It has often been to my advantage to be willing to learn a new language for a new project or a new job, giving me opportunities I wouldn't otherwise have had. I learned Oracle PL/SQL to integrate a 7-8 figure Rails app into an accounting system when nobody else volunteered. I learned Rails to get into ecommerce. I learned PHP to become a startup's only web developer so I could write cool audio processing tech in Ruby. I learned Ruby to speed web development in my own startup. I learned Scala to get into the San Francisco market. JS. Java. Kotlin. POSIX shell. C++. C. Etc.

Unless a developer/engineer just wants to be a cog forever, I highly recommend some flexibility on language. Solving real problems is way more interesting and more useful than being a framework stickler.

sidlls• 8 years ago

Why is this surprising? For years employers have included proficiency with a specific brand of tool (language) as part of their job descriptions. And in the Bay Area anyway there is often a lot of talk about being able to use any language you're comfortable with in the interview process, but in practice unless you use the language(s) in the stack you're interviewing for it's a harder sell.

I self-select myself out of jobs that have specific languages in the job listing if I can't honestly say I've used them professionally.

dizzystar• 8 years ago

For some reason, Rails seems to always have some weird commentary attached to it.

Years back, I've had people tell me they stopped using Rails because it was too hard to find good problem solvers. That didn't diminish the continued success of the framework.

As an antidote to the comment, I was recently at a Ruby meetup. Everyone was on Rails and everyone was younger.

pmarreck2• 8 years ago

Spotted the guy who's never used an immutable language with pattern-matching

oregontechninja2• 8 years ago

It's because we don't like or approve of rails. It doesn't make business sense to us (us being a completely anecdotal group of young developers I'm friends with). There are other solutions that provide sufficiently more developer speed and safety, while also providing much better performance than any rails application.

Edit: I guess I just hang out with like minded people, but our biases shouldn't negate the fact that this is a very common feeling where I am.

erokar• 8 years ago

What other solutions are you youngsters using then? Elixir/Phoenix? Django/Python? Node? Haskell?

michaelbuckbee• 8 years ago

What stack are you gravitating to?

oregontechninja2• 8 years ago

To answer many of the replies:

(Most prominent -> least prominent)

Web-related: Go, Elixir, JavaScript, Python

Desktop GUI: Python, C++

Game-Dev: C#, C++

Really its a matter of how much you'll pay us, and I think we've been scarred by too many bloated Rails apps and Wordpress sites to want to work on those.

chaostheory• 8 years ago

I don't think it's that newcomers won't like Rails. I feel it just makes sense to go all Javascript instead since that's where the momentum is now and doing everything in one language has a lot of benefits especially when it's something as ubiquitous as javascript.

tonyedgecombe2• 8 years ago

That wasn't what I was thinking about, there are good reasons to choose one stack over another once you are in a job. When you are job searching though there are a ton of criteria: salary, opportunities to learn and develop, autonomy in the role, enlightened management, realistic schedules, short commute, holidays, decent desk, chair and screen. I'd put all of those over a choice between Ruby and JavaScript.

markoman• 8 years ago

Ruby is still a beautiful language, particularly for its object oriented-ness. And I think Ruby's nature, simplicity and power appeals to young people, however the resurgence of a towering Javascript/NodeJS is hard compete with. These are market forces that really matter when you're wondering what language & platform to use for your MVP. In recent surveys, Ruby & Rails has fallen to the bottom of the list among the former stars of programming languages. Python has data science & machine learning to keep it strong and new stars Elixir/Phoenix and Golang are sucking up a lot of oxygen that would otherwise go to Ruby & Rails. And let's not forget Bubble (visual app building) and the Zero Code Startup.

I really think Pedro (the blog post writer) has an excellent point about being a polyglot but trying to qualify as a Senior Engineer except I'm older and have even more platforms & languages behind me. Its a serious problem because I have the experience to easily be a Sr. Engineer or manager but my experience isn't concentrated long enough anywhere to make me useful enough to warrant the role.

pjmlp4• 8 years ago

Ruby also suffers from top quality JITs vs what JS has.

The only good option being JRuby, as far as I understand. I am not at all into Ruby.

Regarding being polyglot and seniority, a possible solution is to work for consulting companies that focus on multiple stacks.

cutler12• 8 years ago

Not so fast with Elixir. According to Indeed.co.uk's API there are 18 Ruby jobs for every Elixir job. Yes, there are 3 times as many Python jobs but Ruby isn't exactly dead.

pjmlp4• 8 years ago

It is always on by top list, after learnig what the application and domain is all about.

The majority of HR departments tend to suffer from myopia for anything beyond the last couple of months on the current employer.

So always take care not to land in something that will be hard to get out of.

innocentoldguy2• 8 years ago

The language an employer uses is high on my list when evaluating a potential employer. It tells me if the company has put thought into what they want to accomplish and what technologies would best serve them in accomplishing their goals vs. choosing their technology stack based on popularity, brand loyalty, or some other subjective criteria. I typically haven't found joy in working on projects where I'm using tools that don't easily support the company's goals and vision.

pmarreck2• 8 years ago

Would have been a bit more interesting had he passed through a BEAM VM language on the way...

blunte5• 8 years ago

Clojure does not have an alien syntax. As with Lisps in general, it has almost no syntax. (operator param param ...) Done.

grzm• 8 years ago

Alien is relative. For someone who has only worked with, say, Algol derivatives, it can take some getting used to. Likely less than people often think, but it's still a shift. And it's hardly the point of the submission as a whole.

jrs95• 8 years ago

Aliens on the other hand isn't relative at all, it's objectively the best film in the franchise.

ken2• 8 years ago

It has much more syntax than any other Lisp I know, and it seems alien even coming from Common Lisp. In addition to the usual (list) and 'quote and `backtick and :keyword and ;comment, it has [vector] and {map} and #{set} and #(function) and @deref and #"regex" and ^metadata and #?(:conditional) and ...

(Yes, several of those are implemented as reader macros. I don't see how that would make them any easier to learn than the same feature implemented as "syntax".)

That's not a knock against it. I think Clojure is the best general-purpose language today, but we've come a long way in the past few decades. Lisp is no longer a language whose implementation fits on a blackboard (and everyone extends it in their own way). We've discovered a bunch of common functionality that almost all programs need, and pushed it up into the stdlib and language.

solaxun• 8 years ago

True, but i don't have to remember 5 different map implementations either :)

dragandj• 8 years ago

It's only optional though. You can use (list 1 2 3), (vector 1 2 3), (hash-map 1 2 3 4), and (fn [x] (inc x)).

agumonkey3• 8 years ago

It seems that some people really really love syntacticfull languages rather than uniform symbolic/functional notation.

oblio2• 8 years ago

Considering all the mainstream languages, some would argue that most people prefer them.

lispm2• 8 years ago

As with Lisps in general, it has almost no syntax

That's not true. Lisp has lots of syntax - actually more than most programming language, because the syntax is arbitrarily extensible via macros.

The idea of (operator param param ...) is only valid for function calls, but even then the syntax is slightly more complex, since several Lisps have keyword arguments.

But besides (operator param param ...) Lisp also has:

((lambda (arg ...) . body) param ...)

(special-operator ...)

and

(macro-operator ...)

Each special operator comes with syntax. Example is LET.

LET is not

(LET param param)

but

(let (arg ...) declarations . body)

where arg is arg | (arg value)

declaration the is something complex like

(declare (type (integer 0 3) arg))

for a type declaration for the variable arg, which is an integer in the range of 0 to 3.

lkrubner• 8 years ago

This is a bit odd, that concurrency would be listed as something they gained from Java, rather than Clojure:

"Clojure: considering the difference between being easy and being simple. Clear difference between data and logic that changes that data. Distinction between pure functions and functions with side effects, try to separate them. Let’s try to make simple code by default."

"Java: performance, concurrency and strictness."

Maybe they mean they were forced to think about concurrency in Java?

I don't think any reasonable person would argue that concurrency is easier in Java than in Clojure.

mtarnovan2• 8 years ago

You may be right, still, modern Java does have some excellent concurrency libs, like Akka https://akka.io

drawnwren• 8 years ago

The author mentioned that the Clojure project never had to scale. My guess is that the size of the Java project demanded concurrency and the Clojure project didn't. Overall, this blog is light on details and heavy on how the languages/projects made the author feel.

SomeHacker44• 8 years ago

My reaction to this claim was that, since Clojure is on the JVM, any advantages Java has, Clojure also has.

Of course, idiomatic Clojure might require less mindshare to make highly performant, concurrent code...

jcadam6• 8 years ago

I've tried a lot of different languages over the years including Ruby, Go, Scala, and Haskell.

Ruby actually isn't too bad if you don't use Rails. Between Rails and stuff like Spring over in Java-land I've developed a strong hatred of huge frameworks :)

Clojure, however, is the one language that just 'clicked' for me almost immediately. In fact, I'm pretty certain I'll be sticking to Lisps as much as possible from here on out. That is, when I have the choice: I work in a Java shop during the day like everyone else :O

cryodesign• 8 years ago

What libraries do you use for building web stuff?

Over on Reddit[0] one of the problems for newbies to Clojure is not knowing what to use for web development.

https://www.reddit.com/r/Clojure/comments/858g9z/what_clojur...

jcadam6• 8 years ago

compojure-api[1] is great for building a REST API, and I really like HugSQL[2] for talking to databases. Buddy[3] is good for handling auth.

[1] https://github.com/metosin/compojure-api

[2] https://www.hugsql.org/

[3] https://github.com/funcool/buddy

swlkr• 8 years ago

Clojure also clicked with me too, and I also dislike huge frameworks.

There's a trade off there though, rails gives you so much, you almost forget what the problems are with slapping different libraries together.

Definitely room for a "blessed" path to web dev in clojure.

serpix• 8 years ago

re-frame is the uncrowned king of web dev at the moment, there is nothing like it out there

kureikain6• 8 years ago

I'm agree with you as well except the Rails point.

I have used and deploy Go/Elixir/Clojure to some certain success. One thing I feel is that no code is as beautiful as Ruby code to my own eye.

What make Rails bad in your opinion? Is its performance? I think Rails is just a framework with many utility/helper to help you out.

NegativeLatency2• 8 years ago

I think there's a valid case to be made that Spring and the rails auto-loader are pretty annoying/stupid in larger projects (or anytime you're going against the grain).

Every framework has its downsides. Personally I think rails is nice (I am very productive with it).

cutler12• 8 years ago

If you want end-to-end Clojure/Lisp while retaining access to large ecosystems there's Clojurescript for the browser and Node.js, Hy (http://hylang.org) for scripting and data science plus Clojure for JVM/large applications with performance. Now you can get a VPS with 4Gb of RAM for £5/month at Hetzner (http://hetzner.com) so JVM memory usage is no longer an issue. These are exciting times indeed for developers.

oulu2006• 8 years ago

I had a similar experience.

I felt so strongly about not wanting to go "backwards" anymore and use Go/Scala/Java etc I started my own company so I could dictate the technology decisions, so naturally I used Clojure!

I still use Javascript in most of the UX because ClojureScript I felt wasn't ready for primetime production but we'll be phasing that out over the next few years into ClojureScript.

itchynosedev• 8 years ago

As someone who'd always pick CLJS over Js, for the heck of it I tried to build React / Redux / React-router based app and was blown away at how dev friendly the experience was.

No fiddling with tooling, the entry barrier can't be lower. With CLJS it's always figuring out the latest versions, trying to get Figwheel off the ground is at least a day worth of work for me. What was piggieback again and why don't I have it? Which profiles are loaded implicitly by lein, should I use figwheel-sidecar? Then add building your app to be reload friendly (even though by default it's a good practice)

There's just so much going on even after having built 3-4 projects with CLJS and using the same stack, I am still struggling.

Once you get through the first few days of battling with libs it's breeze.

That's where Js gets behind. Redux / React is all about transforming and shaping your data. You end with lots of boilerplate. Even though ES6 is drastically better with syntactic sugar for manipulating data, it's still far behind Lisp nature of data transforming.

It's a tough choice nowadays. I want to get moving fast and feel strongly inclined towards sticking to Js.

mnm1• 8 years ago

Same here. It's really hard for me now at my day job when I have to write OO. Clojure and functional languages opened up my eyes to OO shortcomings I've been trying to work out for over twenty years. Since I started, I've always felt that there were many things not right about OO and developing using these giant frameworks with so many useless abstractions has gotten old and tiring. Most of my time is spent working around the shortcomings of OO nowadays rather than writing actual code for business purposes. Since I started with Clojure, I have little patience for the complex for complexity's sake song and dance of OO. I'm trying to go full time with Clojure. I'm shocked that the author couldn't find Clojure programmers. Must not have offered remote work.

jcadam6• 8 years ago

I know. You think I'd be sitting here slinging Java code if there was a shortage of Clojure programmers?

Even in my local area (not a tech hub), I'm aware of one small software shop using Clojure, and they have no trouble finding people.

joshmn3• 8 years ago

The articles touches on this but just to reiterate because it's worth saying: The most important thing about Rails is knowing how the internals work and maintaining a clean code architecture. Too many times have I seen a mess in Rails because developers only use the APIs and DSLs given to them.

The best Rails codebases are the ones who have ample "vanilla" Ruby and just happen to use Rails alongside said Ruby.

jwdunne2• 8 years ago

Really interesting comment.

I've started working on a Rails project. I don't have any professional experience with Rails in particular.

Can you recommend any code bases I can read that meet these criteria?

joshmn3• 8 years ago

My personal favorite codebase is GitLab (thanks syste and team!) — they do a very fine job of pumping out Ruby while hanging out in the Rails ecosystem. https://gitlab.com/gitlab-org/gitlab-ce — points of interest are in lib, as well as how they organize and call service objects from app/services.

Xeoncross• 8 years ago

I'm waiting for JavaScript to consume everything. https://www.destroyallsoftware.com/talks/the-birth-and-death...

slowmovintarget• 8 years ago

As a hiring manager, I now look for at least two languages, and they don't need to be the tech stack we're currently using. If you're a good developer, and you know more than one language, you understand that picking up another is not an insurmountable barrier. You'll pick up our stack soon enough.

What I need to know is if you can think critically, not if you already know what we plan to teach.

tro2102• 8 years ago

Same here. Depending on the team I'm leading, I can actually consider not having the current stack a plus, as an outsider's perspective on architecture can help grow a team and codebase that's been stuck doing things the same way for a long time.

There's some penalty in ramp-up time, but I find it more than pays for itself down the road.

whb07• 8 years ago

What else do you look for ? I recently spoke to a hiring manager and he told me that my resume made me look very “green”. It’s only after talking to me that he noticed my resume paints a bad picture.

CryoLogic• 8 years ago

I switched from rails to full-stack js and couldn't be happier. EmberJS + ExpressJS is so simple to set up, and than you have everything in one language and you can even share files and just use a build script to distribute them to client and server (e.g. regex)

whack• 8 years ago

This might be a stupid question and a tangent, but what does he mean by: "don’t use raw strings as constants"

w4tson• 8 years ago

Probably saying something like

  public String getDescription() {
    return “some constant”;
  }

Versus

  public String getDescription() {
    return FOO_DESCRIPTION;
  }

it’s a fairly weak example but you get the idea.

NegativeLatency2• 8 years ago

I really can't tell, but if I were to guess it would be the difference between something like `User.where(thing: 'foo')` and something like `Foo = 'foo'; User.where(thing: Foo)`

So you can refactor/find things that use Foo easier than 'foo'. You would probably get editor support for the constant "Foo" and not for the string "foo".

pimeys6• 8 years ago

My career so far:

Delphi -> Microsoft stack -> Rails/Ruby -> Scala -> Clojure -> Rust

The stuff I remember well starts from Ruby. Good things:

- Ah man code is like a book.

- Lots of people were writing Ruby back then, so lots of libraries.

Bad:

- Deployments in general, this was before Docker, but I prefer having single binary/jar deployments

- Slow

- Lots of runtime errors

- You need lots of tests

Scala, good:

- If using IntelliJ, the development experience is kind of slick

- Quite modern, JVM libs work

- You can go functional or OOP, whatever you wish

- Fast

- Type system helps you out, so no need for that many tests

Bad:

- IntelliJ, I need my Emacs

- SBT is not very nice in the end, making a huge jar file can cause trouble sometimes

- Not the biggest fan of implicits

Clojure, good:

- Lisps are SO MUCH FUN to write

- ...especially if writing pure functions, stuff like code generators

- Emacs is good here, Cider rocks!

- JVM libs are available

- Leiningen is definitely nicer than SBT

- Everything is pretty easy and straightforward

Bad:

- Concurrency and effects can cause trouble, especially if doing it through Java libraries

- Leiningen is nice, but slow. You must use Cider.

- Runtime errors, as with every dynamic language

- Again lots of tests, but at least they're fun to write

Rust, good:

- Concurrency, IO and so on. Just damn nice with Rust

- Refactoring without fear

- Cargo is the best dependency management / build tool ever

- Small binaries

- Total control of CPU/RAM, you can do pretty fast systems

- If it compiles, it usually works

- Type system is great, libraries are quite nice already

- Community feels like the good old Ruby days, but better

Bad:

- Borrow checker still sometimes hurts, hopefully non-lexical lifetimes land to stable soon

- Problems with the current 0.1 tokio and futures can be pretty daunting. It's not a good idea to do super complex stuff with them yet

- Write your own libraries, especially if you started two years ago. That was fun though

I think the next thing I must grasp well is Haskell, just for the fun of it.

hashmal2• 8 years ago

Community feels like the good old Ruby days, but better

I really miss that old Ruby community. It was full of that hacker spirit, everyone trying stuff, no one to crush your creativity. Then the startup hipsters took over and came up with good practices, style guides, gems you absolutely had to know to get hired, etc.

It drove me away from Ruby, actually. It just wasn't fun anymore.

I hope it doesn't happen with Rust. I did not have so much fun writing code for a long time.

pimeys6• 8 years ago

This definitely feels my own golden age now being able to write Rust and seeing all these great people doing interesting projects and hacking things...

innocentoldguy2• 8 years ago

Your comment really speaks to me. I'm in the process of transitioning my career out of development altogether for the reason you mentioned getting out of Ruby. It just isn't fun anymore. I haven't been able to find a company with a good hacker-spirit since 2010. I like programming, and will probably continue with languages like Elixir and Haskell, but as far as the day-to-day work goes, I'm done.

freeslugs• 8 years ago

thoughts on rails 5? coming from rails 3 -> 4 -> 5, it solved a lot of issues for me.

kureikain6• 8 years ago

I may sounds weird but Ruby is what make me look more into functional programming. I get done a lot with Ruby due to all method it has on Array/Object/Enumerable.

The beauty of `&` is awesome and I discover that Elixir/Clojure has that and bring it to next level. I think Ruby has inspired many other language to take that path too.

One of the thing about Ruby is that it optimize for happiness, which sound weird. But I really feel happy to write Ruby code. I feel like the language really care about me.

Who don't want to have stuff like this:

``` 10.seconds.from_now ```

Or just call method without `()`, and without even wrapping hash in `{}`.

Of course, lots of these are do-able in Lisp and I like Clojure. But I think the flexibility Ruby gives us is under estimated.

pimeys6• 8 years ago

It looks nice, but then again:

  irb(main):002:0> 10.methods.count
  => 133

Oh well...

kureikain6• 8 years ago

What's wrong with this? What is your expecation?

pavlov2• 8 years ago

  *> 10.seconds.from_now*

I don't understand this kind of weird "urban sprawl OOP" where classes are extended with anything.

Why is 'seconds' a method on numbers? Is there also a 'pixels' method so that I could draw a line like this:

  10.pixels.from.top_left_corner.to.southeast.using.red.stroke

If this doesn't seem like a sensible way of programming graphics, why does the 10.seconds thing get a pass?

tinco• 8 years ago

It's not just 'anything' that objects are extended with in Ruby, they are extended with suitable methods pertaining to the domain at hand. 'seconds' is a conversion method of one type into another. You might as well ask why do objects have a 'toString' method. Because it is convenient.

kureikain6• 8 years ago

If you think about it, that's just fluent API. And it's up to your to use it to design thing that's convenience and readable for you. When you design an API, you put it to the context. When in context:

10.seconds.from_now

is beautiful to me.

Let's do a quick google for "Fluent API in Java" and you will get something like this:

Invoice inv = Invoice.builder() .createdOn(new Date()) .withDocumentNumber("5150") .shippingOnTrailer("2112") .suppliedBy(InvoiceActor.builder() .named("101") .as(InvoiceActorType.DC) .build()) .beingSentTo(InvoiceActor.builder() .named("42") .as(InvoiceActorType.STORE) .build()) .with(InvoiceItem.builder() .as("TK421") .orderedQuantity(10) .shippedQuantity(8) .build()) .with(InvoiceItem.builder() .as("FN2187") .orderedQuantity(5) .shippedQuantity(5) .build()) .build();

The only difference here is that Ruby allow you to attach method to anything.

But then you have category in Objective C, extension in Swift/Kotlin.

The language gives you the tool, to make your job easier, that's why I wrote "I feel happy when writing Ruby" because I have that power.

To even protected you from changing everything, you can also use refinement to scope this, though it seems underestimated currently IMHO.

When using it the right way, it helps everyone write readable code.

Back to your example:

10.pixels.from.top_left_corner.to.southeast.using.red.stroke

It's up to your however you want to design it.

zombieprocesses2• 8 years ago

That reminds me of me after browsing HN's flavor of the month. Go -> Clojure -> Ruby -> Rust -> F# -> ...

iammiles• 8 years ago

Let me know when F# becomes flavor of the month. I'll gladly hop on that bandwagon.

zombieprocesses2• 8 years ago

https://news.ycombinator.com/item?id=13708453

https://news.ycombinator.com/item?id=14506287

Enjoy. If you want to dip your toes in the water, you can go through

https://learnxinyminutes.com/docs/fsharp/

for a quick introduction.

If you have background in functional languages/programming, most of it should look familiar. If you come from an OO or a procedural background, then it might take some getting used to.

But if you are looking to get a job at a windows shop, I'd stick to C# ( or VB.Net ) as that's where most of the jobs are.

brandonbloom• 8 years ago

Years of Clojure has made me a dramatically better Rails programmer. The biggest change for me is that I now treat ActiveRecord models as gloried hashes with easy-access to a namespace of related functions (ie. methods) that operate on all manner of underspecified partial data, rather than traditional OOP-style objects with sophisticated invariants. I'm also very careful to strictly separate reads from writes, and to discard/reload all mutated objects immediately after transacting with them.

My new business is built on Rails for a very long list of reasons, not the least of which is that both Ruby is quite a nice language, and Rails is actually quite good for back-office/lo-fi/quick-and-dirty, server-side-rendered UX with relatively low web traffic.

cutler12• 8 years ago

Have you tried Elixir/Phoenix?

pbreit• 8 years ago

I am shocked at how many situations I've been in where the engineering team has delivered a drastically over-complicated, usually micro-service-based, system. Ten engineers working for a year where I could easily see 1-2 Rails/Django devs delivering more in 2 months.

blackmagevivi92• 8 years ago

Clojure was fun overall. The not so fun part was integrating with necessary Java libraries with crazy/stereotypical abstraction patterns. Necessary because Clojure library offering isn't rich; not to knock on all the beautiful open source work that's out there.

From Rails to Clojure, Then to Java, Then Back to Rails

Related Stories