jehna1

I created a modern alternative for creating user interfaces in Javascript. Longwood can be summarized with these three principles:

1. It's just JavaScript This view library does not invent a new syntax for templating — you can use traditional Javascript without any build tools.

2. Beginner friendly No magic. Longwood does not introduce complicated concepts that you'll need a PhD in computer science to understand.

3. Strong Typescript support When you're ready, jump in with Typescript and have clear and strong types there to help you.

Let me know what you think

There's also VerbalExpressions library that's been ported to 30+ languages: https://github.com/VerbalExpressions/JSVerbalExpressions

It's other way around: create-react-app pulls too many dependencies because React is bloated.

They could have made React lighter and require no compilation. But instead they created a scaffold and fought complexity by adding more complexity.

It's not part of Javascript, so you'll always need Babel (or similar transpiler) as a dependency and some kind of build step.

It's additional complexity when you could have solved the same issue by using better design on the API level.

I'd argue it depends on what you're used to. Coming from React you could argue Reagent is not readable. Coming from Javascript you could argue that Objective-C is not readable. But it's more that you need a moment to get used to the new syntax.

Anyone looking for a non-Java implementation: This library has been ported to 30+ languages, and you can find a list of them at http://verbalexpressions.github.io/

It already is. In 30+ of them. You can find them on: http://verbalexpressions.github.io/

Team always shares the responsibility. We do a ton of work to establish trust inside a team so you would share things that are affecting your work instead of trying to hide them so you don't get sacked in performance review.

We also make it very easy to change teams so everyone would find the best environment for themselves.

Currently working as a developer for a company that organizes itself in small groups without bosses and I must say I could not think about going to work for a company where I would have a boss.

I think a very good metric would be the number of maintainers of a package and how well funded they are.

E.g. React has a huge resource pool and people are getting paid for development, while some (most?) packages are single dev with no funding.

Perhaps making this kind of metrics visible would introduce some humility for people pressuring latter maintainers.

The first time you did this your browser asked for a permission via browser's native permission modal

Hey HN

This is my hobby project I've been working on. At the moment there are 15231991 pages in English wikipedia, and a whopping 671872114 links between them.

This project uses custom-built Rust parser to parse through the data (in 15 minutes!) and Google BigQuery to find the shortest path between two pages using a rather simple breadth-first search query.

Let me know what you think!

Ok, the first thing in my mind is how to share passwords with your teammates.

Sending a password:

   echo 'hunter2' | openssl bf - | curl -X POST --data-binary @- https://patchbay.pub/mysecretpasswordhandle

Receiving a password:

    curl --silent https://patchbay.pub/mysecretpasswordhandle | openssl bf -d -

This uses end-to-end encryption (Blowfish cipher) that relies on a shared password.

I've been recently using @grammarly/focal for state management and reactive flow programming.

It also uses rxjs behind the scenes, which I really like has gained some ground with Angular lately.

Have you seen bad OOP code? It's an unreadable mess of ObjectManagerFactory classes where everyone mutates everything.

Have you seen bad functional code? It's an unreadable mess of monads, flatmaps and partial composition where you're not really sure how many arguments a curried function is whitholding.

Have you seen bad procedural code? It's an unreadable mess of nested if-else statements where you're not really sure what state the world is in.

There are no silver bullets, only different solutions to different problems

Premature optimization comes in many forms, and at least these three cases are doing more harm than good:

1: "It's good practice"

For example: Wrapping every function implementation in a memoize function may seem like a good idea (= it prevents doing unnecessary work-heavy stuff), but it actually makes code both harder to read (more boilerplate to skip when reading) and most cases slower (= even when a function is executed only once, you're doing extra checks and function call).

2. "We're gonna need this soon"

For example: many times I've implemented an abstraction that makes sense for sharing code with a feature that I know we'll be implementing soon, only to find out priorities have changed and that other feature never gets implemented. What's left is an unnecessary abstraction that only makes the code harder to read and maintain.

3: Optimising for speed/lines of code

Unless you're building a game engine, it rarely makes bang for the buck to optimise for speed until you have identified an actual bottleneck in performance.

Same for one-liners. It may be cool that you know how to write 10-line function as one-liner nested ternary, but your "clever" code is probably less readable and harder to maintain.

"Respects your freedom" badge seems to be hardware-related. This is exactly what we'd need for the software products too!

> I believe and hope that we will see less tracking in the future

As a consumer I sure hope so too, but I'm only seeing increase on different methods of tracking at the corporate level; tracking software is becoming more cheap, accessible and easier to use

Can you tell more about the "organic" label?

Here's a somewhat related project that aims to make regular expressions more verbose:

https://github.com/VerbalExpressions/JSVerbalExpressions

Here's a simple example for matching URLs:

    const tester = VerEx()
      .startOfLine()
      .then('http')
      .maybe('s')
      .then('://')
      .maybe('www.')
      .anythingBut(' ')
      .endOfLine();

The project has been ported to many different languages and it outputs a normal regular expression that you can use to match your text.

Thank you for taking time to answer! I definitely relate to having a ton of desktop spaces open all the time.

> What price would you feel comfortable paying for Pi?

After reading through the website and watching the product video, I'd be willing to pay $15-20 to try it out and see how many of my productivity problems it can fix.

> Would a free trial make the $70 price point more reasonable for you?

Free trial would definitely help me evaluate all the features, and if they're worth more for me. I can see that if the app is a hit, it's worth $70 for me. But at this point I fear that it's not perfect, so $15-20 is something I'm willing to throw away to see if the app fits.

> Would your rather pay a subscription?

I have a personal problem with all subscription models: I instantly calculate what using the app will cost in 3 years to get perspective.

Now if you'd set $6/month as your price point (to match $70/year), I'd see it as committing to $210 over three-year period.

I know some people don't see subscription models as scary as I do, and it's a really common way to lower the bar to purchase things nowadays. But I'm very cautious of anything subscription-based.

I think I "got" what Pi is all about and I think I like it.

$70 is just out of the range of value I can see Pi would benefit me.

Can I ask how many users you have so far? How did you start with Pi and validate the idea?

Wanted to try to create a NES game on a game jam, so I started to create a bootstrap project for creating a NES game in C: https://github.com/jehna/nes-bootstrap

Try product-specific subreddits like /r/coolgithubprojects

There are other subreddits too which are trying to find cool projects like yours.

Other approach is to write a blog post and post that to e.g. /r/opensource

Wow, cool project!

You should try Reddit. It has a lot of niche communities where you could share your project.

Also Google for things someone who seeks for a project like yours would Google. That gives you a rough idea of what kind of sources people use to find tools like yours.

Also some directories list specific tools (like "awesome" lists of github). Try listing your project there. Or even starting your own "awesome" list project on GitHub :)

I agree that it's crucial to have a good license for your project to spread. But I think it's one of those things that takes a lot of mental effort when you do it the first time.

Fortunately GitHub helps you quite a lot nowadays with choosing the license for your project.

Deadlines are a bliss. They help you to both reduce the unnecessary, but also to fail faster.

Sunken cost fallacy is a real thing even in side projects.

The differentiating qualities of the project is indeed very important. But I think it's more than okay to also say that "this is a clone of xxx I'm using to learn yyy".

TL;DR: how to turn a side project into an OSS side project: start by scratching your own itch, timebox tweaking, write a good README, hit publish. Easier than you'd think.

here's the project https://github.com/jehna/ga-lite

Hey, I'm the author of this blog post. Hit me with questions if you got some!