Does anyone use ruby without rails

Ruby is definitely not dead. If we consider it together with Ruby on Rails, then this platform has grown enough to be a stable, mature and rich solution for web development. Every year so much happens in the ecosystem, new version releases, conferences, lots of new learning resources.

It all proves that Ruby is a vital solution for web building. I don't think that saying "dead" for a language or framework is possible at all — there are tons of different businesses which require different types of software and have different needs, and that every piece of code written can be used somewhere.

For sure that applies to Ruby and Rails — it's still very popular, has a very active community, constant updates and new version releases. Ruby is still a very viable choice for fast prototyping, and not-so-complex web applications.

The only applications we still use Ruby on are applications built at the peak of the Web 2. Performance and scaling are two of the biggest concerns. While Ruby can be scaled, doing so is considerably more expensive than scaling other languages , and the options are much more limited.

The lack of flexibility also hurts. Ruby on Rails apps need to be built in a very specific way. I wouldn't say that Ruby on Rails is dead at all. The simple proof; GitHub runs on Ruby on Rails. Aside from Github however, RR i s still relevant and is used by a considerable number of startups, especially in Vancouver. These days it is used as a base for prototyping, scalable apps, and content management systems.

This is despite Node eating into Ruby's popularity. It's also hugely popular in other countries like Japan, which shouldn't come as a big surprise considering that's where Yukihiro Matsumoto the chief designer of Ruby programming language is from.

Timothy Orbasido , Full-stack Developer at Numinix. The truth is that Ruby just got a recent minor update to 2. Ruby on Rails is not dead, it's evolving. I'm excited to see where it'll go next and what to expect in the newest update. In my personal opinion, Rails gained notoriety because it was misused in the wrong places. Each case needs to be analyzed separately, and in edge cases, one should consider switching to a different technology stack.

When we try to create everything from the low level up, we often end up seeing how little we know about the application functioning. No, unfortunately not. You need to remember, however, that any additional gems always impose specific limitations on us and on our projects at least their business side. We often end up never reaching or crashing against these restrictions, but I can easily imagine a situation where we encounter a blocker related to a gem we added barely a week ago.

But how can we establish where that particular line runs? Well, it's actually very difficult to do that. This is the reason why deep analysis of particular requirements and additional information is so relevant. It helps us understand how a given feature depends on a domain and whether there are any specific edge cases to consider. If you find even one small bad omen in the process, you better find your own implementation. Trust me. Given my experience, I suggest a couple of simple steps that anyone can follow should they encounter a difficult issue in our domain not in the framework!

How can we understand how a library works if it has no documentation? Source code and tests. Now, Ruby is currently in the top 10 barely, as 10 in the Tiobe Index. That's remarkable for a new language and it's probably all due to Rails.

Ruby has been holding steady and may beat VB someday. Ruby is well-regarded technically so it is safe to assume that some day in the future there will be Ruby development jobs. This may take a long time, and they may always be Rails or Rails-like jobs, as web applications may well continue to replace everything else. Since I can't imagine anyone willing doing straight-PHP work, it's safe to assume that all of the PHP activity is in web programming, and in that case it's even safer to assume that all the Ruby work is web app work.

The original business case for adopting Ruby on Rails in one of my previous jobs was that the Java option would take too much time - so we were allowed to explore other alternatives That kind of pressure acted as an incentive for the business to let us consider other technologies. Ruby got a lot of credibility with software engineers as an interesting language to consider when people like the Pragmatic Programmers and Martin Fowler started talking about it as a great language to think in.

I'm using Ruby as a code generation language in my rewrite of AppMaker. The decision was influenced by them and by the book Code Generation in Action. Dynamic language support is a hot topic in the. Net space with IronRuby being supported in SilverLight for web client-side programming as well as being a significna language.

It's early days and I don't think there will ever be a career market for it like C or Java but momentum is building. Take a look at MacRuby.

It's an implementation of the language with a nice Ruby style interface to Cocoa. Ruby seems to be a natural fit for Cocoa because its OO implementation is based on the same message parsing model than Objective-C.

I hope this doesn't annoy you all too much, but I was thrown into ruby as an intern at Yahoo! And I really loved it. Now I'm also learning rails on my own, just for fun. I know a guy who changed job just to get more ruby experience. His plan is to start a consulting firm, making stuff in Ruby. Ruby rocks! Stack Overflow for Teams — Collaborate and share knowledge with a private group. Create a free Team What is Teams? Collectives on Stack Overflow. The content length header is the size of the body message in the HTTP request in bytes.

The response is constructed following HTTP specification: the response start-line contains the version number and response status code, followed by headers, an empty line, and the response body. What is a web application without the ability to store data? We need a way to store the data so the next time the server restarts, we can still use the same set of data that was previously saved.

But how would we? Obviously the answer is to store in a database. A database stores information on physical disks or servers. We save our data to a file. We could use a plain text file, but we would have to implement our own format for representing the data in plain text. The good news is that Ruby has a built-in library, PStore, that translates Ruby objects into binary and stores it in a file.

Alternatively, PStore is also able to read from the file and translate the binary back into Ruby objects. The serialization and deserialization is the process of marshaling Ruby objects into binary and vice versa. But wait—we have a working web application written fully only with Ruby libraries.

It took a lot for us to get here. We needed to understand all the low level details of how TCP runs, what makes HTTP requests and responses, and how to persist data by storing it in a file. Yep—with more abstractions! The code that implements the TCP sockets to create a network connection is generally similar throughout all the types of web applications—the server creates a socket to accept clients.

HTTP requests and responses are also standardised across all types of web applications. A web developer would have to understand intricate details about the network protocols. Instead of creating a network connection and writing HTTP parsing logic every single time we want to start a new web application, we can use an application server.

An application server is a program that deals with HTTP on behalf of the web application, it accepts and parses requests, and then generates and sends responses. Just like how HTTP has its specifications, application servers too have an agreement on how the server talks to our code. A Rack application or a web application that follows Rack specification is any Ruby object that responds to the call message, accepts a hash argument called the environment, and returns a three-element array that contains:.

Instead of instantiating our own TCP socket, we defer it to Puma by following the Rack specification. The first thing our app does is create a rack::request object with the environment provided. This code was previously our case statement that determined which endpoint to lead the request down. Now we use built-in request methods like get?

As outlined in the Rack specification, we need to return a three-element array that consists of the status, headers, and body. Note that the status has to be an integer or larger, the headers has to be a Hash and the body has to be an object that responds to each. To make things simple the body object is a Ruby Array in this example. Now that Mirth is a Rack application using rack::request , we can now use rack::response to wrap the HTTP response objects.

Similar to how rack::request worked, we are encapsulating the response logic of the application using rack::response object. Once the HTTP response object is created and ready to go, Rack will send the response for the application. Similar to how a rack::request object is created, we create a new rack::response object to handle the response.

Again, similar to how you can ask a rack::request questions about the request, you can now modify the response object to your liking based on the different endpoints. For example, in the GET endpoint, we will use write to append a string to the body of the response.