Thanks for mentioning this. Somehow I've searched for something like this before and couldn't find it.

That didn't stop me from using Firefox tough. I just have my first bookmark in the toolbar point to "about: profiles" and use this page to launch new profile instances, create new ones etc.

Are you talking about this? https://addons.mozilla.org/en-US/firefox/addon/profile-switc...

Thats the one!!

I did that too but I encountered fuckery. I forgot what it was though it was a while ago.

Time to play catch up with all the new JavaScript frameworks that were released in this 48h then.

If you try to use it as a GUI designer like Figma it's pretty outdated but I still use it for low-fidelity mockups sometimes and I like it for it's simplicity.

This looks like a good alternative to Foreman (https://ddollar.github.io/foreman/). Do you know about it? What advantages do you think Porter has over it?

Congratulations on the cool project.

Thanks! After I started building and sharing my progress on Twitter some did suggest foreman. I just took a quick look and I think Porter is a bit easier to use because of the porter.yml file you can add to every project. Which may read a bit easier compared to the procfiles. One or two other advantages could be the interval restart feature, where you can restart services automatically after a certain interval (useful for unstable services). The second advantages is something I'm working on at the moment, where you can define processes to restart if certain files have been modified.

You can say that in portuguese, it's completely correct but it seems to be much less used than "junto ao muro" as in "next to the wall/adjacent to the wall". Even being correct in this use, "contra" is a word very charged with adversarial context. Maybe that's the source of the strangeness the thread OP feels about the use of "against".

This is great!

I love Rails but have used Sinatra and Padrino in the past. The knowledge you get using these frameworks can sometimes be brought back to your Rails apps to improve some things.

I hope I can have some time in the near future to use Hanami in a real world project.

Congratulations to the team.

I agree! My rails applications became way more maintainable since I started being interested in DRY and Hanami:)

I get what you're saying. Specially if you think of it more as a microblog that you share toughts.

How do you feel about timestamps as titles (and URLs)?

Maybe having an option to use a title or just a timestamp.

From a quick look it's nice but I think the grey background color for the inputs is not a good choice, it gives the impression that they are disabled.

There was a time when some stuff was being extracted (removed) from Ruby core and becoming gems and I really tought PStore and YAML::Store were going to be among those, but no, they decided to keep them in core. So maybe there are some important enough use cases that justify it being there.

Or maybe it would be a hard task that didn't justify the effort.

Many parts of the stdlib are being slowly gemified, that's the case of `pstore` too hence why it has it's own repo.

It's now no longer technically stdlib, but a "default gem", a gem that is installed by default with ruby, see: https://stdgems.org/

Since a few years every version remove one or two rarely used default gems. The Ruby core team just doesn't like big breaking changes.

I love the simplicity of YAML::Store. It was introduced in Ruby 1.8, almost 20 years ago (https://github.com/ruby/ruby/commit/55f4dc4c9a5345c28d0da750...).

I even created a little gem when I was starting with Ruby, 10 years ago, that was a very thin wrapper around it so that I could play around using an ActiveRecord like syntax (https://github.com/brunnogomes/active_yaml). I used in some pet projects so I could do stuff like:

  p = Post.new
  p.title = "Great post!"
  p.body = "Lorem ipsum..."
  p.save

  Post.all # => [#<Post:0x895bb38 @title="Great post!", @body="Lorem ipsum...", @id=1>]

  Post.find(1) # => #<Post:0x954bc69 @title="Great post!", @body="Lorem ipsum...", @id=1>

  Post.where(author: 'Brunno', visibility: 'public')
  # => [#<Post:0x895bb38 @author="Brunno", @visibility="public", @id=1>, #<Post:0x457pa36 @author="Brunno", @visibility="public", @id=2>]

And have access to the data directly in the YAML files.

Good times!

The problem with YAML is that meaningful whitespace means that the size grows quickly for highly nested documents. I don't love XML, but there is a reason I recommended Ox. I've used it for real projects and it never fell over like so many of the alternatives I've tried where databases were not in the cards.

The problem with XML is that angle bracket expressions take up too much space because you need to duplicate element names. I don't love JSON, but there is a reason I recommend OJ.

...

The problem with JSON is that the keys take up too much space because they are duplicated. I don't love BSON, but there's a reason why I recommend bson-ruby.

And I could keep going... ;)

The benefit of using YAML is precisely that there's meaningful whitespace. Different strokes for different folks.