revetkn

To me, the idea is that you have something in your head and you want to "project" it into reality. I suppose the difference between makers and producers then is that makers happen to enjoy the labor part of that projection, while producers don't particularly care about it (nor want to care).

Yes - the JdbcClient API has a similar feel for sure. If you are using Spring, it is a better choice than Pyranid because it integrates well with the Spring txn plumbing. Outside of Spring, I think Pyranid has a lot of advantages.

If you use Java and like to write SQL, check out https://pyranid.com

I stopped using ORMs around 2008 because they made the easy problems easier and the hard problems harder. I wanted to just write SQL and exploit all the power the DBMS has to offer instead of fighting with an abstraction layer, so I created Pyranid in 2015 and keep it actively updated.

I did not really understand CORS until I sat down and wrote a server implementation of it and had to think hard about "what hooks should be exposed to developers for controlling it?"

Most of us I think just "expose a set of whitelisted origins and be done with it".

Here is where I landed for how to specify your server's CORS policy:

https://soklet.com/docs/cors#custom-workflow

There is no public-facing continuations API afaik.

Structure concurrency/virtual threads seem like a good fit for Swing; just have your event handler fire off virtual thread[s] and do your work and call SwingUtilities.invokeLater to schedule the result to be applied on the event loop thread when you're done. Structured concurrency simplifies managing groups of concurrent tasks, cancelation, etc.

Regarding "What's wrong with what .NET did with threads?", see https://cr.openjdk.org/~rpressler/loom/Loom-Proposal.html (relevant part below):

  An alternative solution to that of fibers to concurrency's simplicity vs. performance issue is known as async/await, and has been adopted by C# and Node.js, and will likely be adopted by standard JavaScript. Continuations and fibers dominate async/await in the sense that async/await is easily implemented with continuations (in fact, it can be implemented with a weak form of delimited continuations known as stackless continuations, that don't capture an entire call-stack but only the local context of a single subroutine), but not vice-versa.

  While implementing async/await is easier than full-blown continuations and fibers, that solution falls far too short of addressing the problem. While async/await makes code simpler and gives it the appearance of normal, sequential code, like asynchronous code it still requires significant changes to existing code, explicit support in libraries, and does not interoperate well with synchronous code. In other words, it does not solve what's known as the "colored function" problem.

I find papers like this strange for the same reason. Maybe I'm missing something...

My project Lokalized attempts to solve many of these complex plural/gender/ordinal/etc. rules with a tiny expression language:

https://lokalized.com

https://revetkn.com

I like the fluent API - this looks like a much better way to work with ResourceBundle types than Java's out-of-the-box support. Thanks for sharing.

In my experience, LLMs are terrific for most translation tasks, but you still need a way to encode the data (rules for genders, cardinalities, ordinalities, ...) for storage on disk/database/etc. for 1. performance and 2. consistency/durability. So LLMs are a big part of the solution, but not the whole picture.

My project, Lokalized (from 2017, in Java), has the same goal but took a different approach to the "little language" design. I'm guessing I had the same inspiration as the Fluent authors - existing solutions were just not expressive enough for the real world. Mentioning here because I'm always super interested in seeing how others approach the problem of effective i18n (it's a bit complex). Making Fluent more of a spec was the right call imo; I did not do that with my work.

https://lokalized.com

Is cognition a set of weights on a gradient? Cognition involves conscious reasoning and understanding.

What is your definition of _conscious reasoning and understanding_?

That's how I view it as well, from an end user perspective this is removing an arbitrary rule that you're required to "just memorize" (or be surprised when your IDE complains).

Totally agree, and I also love that so much thought and consideration goes into how the platform gets improved over time. Doing it "right" means taking so many things into account -- many of which are subtle -- and picking the right tradeoffs. Hats off to the people quietly doing the deep work which makes everyone's lives better.

Maybe, but the last straw for me on that platform was preventing tweets from linking to arbitrary, non-doxxing Mastodon profiles (try it and see). I tested it to confirm and deactivated my account afterwards. Who would want to be on a social network like that?

Both Java.

Pyranid - https://www.pyranid.com

I prefer SQL to ORMs and I don't like libraries with dependencies. Really simple mapping of resultsets to Java objects. Plays nicely with DI (I like Guice a lot).

Lokalized - https://www.lokalized.com

Another no-dependencies lib. I don't think any other platform handles translations in a powerful enough way. The magic is a simple expression language that lets the translator specify rules (e.g special cases for certain languages to be more "natural sounding") instead of embedding all that logic in code.

Thanks...I needed a laugh

My take on how to solve the natural-sounding translation problem: https://www.lokalized.com/#a-more-complex-example

The magic is a tiny expression language which understands plural cardinalities, ordinals, etc. so a translator can encode all required logic in a JSON file - the application code can be "dumb".

Localizing well has a lot of complexity - gender, cardinal, ordinal, etc. rules, and then how to combine them with locale-specific special cases (e.g. in Spanish, a 15-year-old birthday girl is a quinceañera)

I am attempting to solve this with a small library that offers full CLDR coverage and a special expression language.

See https://www.lokalized.com

Currently for Java 8 but am porting to JS and Python (probably Swift after those)

Shameless plug: if you're looking for a no-dependencies Java 8 JDBC wrapper, we have been using https://github.com/pyranid/pyranid in production for a number of public-facing projects over a couple years and it has worked very well for us

IMO in 2016 it is important to know the basics well enough to know if what you're doing is bad from an i18n perspective (at least for non-junior positions). Even a comment like "// TODO: localize" is OK

It is often a positive signal that a candidate has worked on software large enough to be used internationally or is thorough enough to worry about it. For most of us, day-to-day software work is about being thorough and careful with design and implementation, not heavy algorithmic lifting

1. "On this particular challenge, I am expecting many will use RegEx as a part of the solution"

Really?

2. "replace(/[^a-z0–9]/ig, '');"

If I were interviewing and a candidate did this I would ask if he/she knows what i18n is

"Unintentional" as in "pretty sure it was an old copy-paste from another app and we forgot to take that line out" :) I don't like the scroll locking myself, even when applied "correctly".

Hopefully the site is at least navigable now on Mobile Safari. We will be revisiting the mobile experience soon. Had not been focusing much on it since the app is form-heavy and doesn't lend itself well to mobile, but for the marketing site we certainly need to focus on it more...first impressions are very important, and a broken page is not a good one! Thanks for your feedback.

Whoops, sorry, our fault - should be fixed now. The viewport meta tag was unintentionally locking scaling and initial zoom level.

Thanks for your feedback - getting the UI right is one of the big challenges for us given the complexity of the system. We've been experimenting internally with different approaches, one of them being a per-user preference "raw" mode that works as you described.

The basic idea is we wanted a hosted Postman which allows you to wire your endpoints together "lego-style" into workflows (step 1 is authenticate, step 2 is fetch a list of users, step 3 is update the first user in the list). You can then shoot someone a URL and they can hit the "play" button and the API calls execute before their eyes. Some other notable features we've added are team support, versioning, and dependency tracking.

The drawback of most hosted services like this is you can't see things on private networks, like localhost or a corporate intranet. We have an OS X native app to circumvent this and a Windows version is coming soon.

We'll try to answer any questions you might have, thanks for checking it out!

Transmogrify - http://xmog.com - Philadelphia, PA Suburbs

We’re a software shop located in the heart of Conshohocken, just a 5-minute walk from the R6 line. The team is a tight-knit blend of designers and developers and we are on the lookout for more engineering talent. If you have experience with these technologies, we’d like to talk to you! Email jobs@xmog.com and let us know you found us via Hacker News.

Preferred skillset:

  * Modern Server-side Java (Jetty, Jersey, Guice, Guava, …)
  * Client-side JS (Angular, React, Backbone, …)
  * RDBMS/SQL experience (Postgres, Oracle, …)
  * Android
  * Ability to work effectively on a team and collaborate with designers
  * A sharp eye for detail (you’re the kind of person who worries about error handling and edge cases!)

  * iOS (Objective-C, Swift a plus)
  * Server-side JS (Node, io.js, …)
  * NoSQL (Cassandra, …)
  * DevOps chops (AWS, …)
  * Any other interesting software experience

Is the normal way to returning "success" values (throwing an exception?)

    var resp = new HttpResponseMessage(HttpStatusCode.Created);
    throw new HttpResponseException(resp);

Pretty much a full admission that everything that Julie said is true.

I have no idea whose side of the story is accurate, but there was really no other way for Github to play this, whether they were in the wrong or Julie was in the wrong.