704 karma · joined April 3, 2012
Business: https://www.joyapp.com
Second: React does a DOM diff and only updates the components that changed. So it's super fast.
Third: when you DO need to use the raw JSON, you have access to it.
Fourth: rebinding behaviors (onClick) etc is done by React seamlessly. And again, uses the DOM diff to be efficient.
That's why I built the following project: https://github.com/silviogutierrez/reactivated
It's very early on, but essentially, completely replaces the template rendering with React components. Still regular markup, but whenever you need dynamic behaviors, it's trivial. And it's all server side rendered.
So basically, looking at https://github.com/silviogutierrez/reactivated/blob/master/c...
You can see the traditional Django context becomes "Props" in the top level component. Then it's React all the way down.
Notes:
1. The most complicated part is the initial setup. You do need to run NodeJS, webpack + Django server. Working on improving that.
2. I like TypeScript and use it here. But theoretically it'll be optional. The Django+Python part is also statically typed using MyPy.
3. No instructions whatsoever yet. But you can see a live site using this stack here: https://www.silviogutierrez.com/ . Notice it's server rendered but has dynamic behaviors that are trivial in React but harder with jQuery + Django. Example: https://www.silviogutierrez.com/blog/making-cck-fields-read-... Look at the nested commenting and moving the form around. Very easy in React.
4. Because of the architecture, adding a much-better-turbolinks style Ajax is trivial. Click around the site above (loading indicator not yet added). The page is re-rendered entirely on the client but gets a server AJAX response.
Hope that's interesting info. If you'd like to try it out, definitely let me know. Once you overcome the setup hurdles, it's amazingly productive. As in, if all you wish to do is `{{ form }}` like old school Django, here's the equivalent sample template: https://github.com/silviogutierrez/reactivated/blob/master/c...
Point by point:
Comments: sure, that's an excellent case for a comment. I meant more for a simple loop over items, etc. In those cases, if you use clear variable names and idiomatic syntax, it'll work. But for vector-space models? Go all out...
Pro-complexity: this is "pro-complexity" in my opinion: https://engineering.hellofresh.com/front-end-microservices-a... . HN seemed to agree: https://news.ycombinator.com/item?id=15566339
Declarative: fair enough. It's been instrumental in our current project, so it's just something we look for. Perhaps too heavily, based on this feedback.
Overall feedback: that's great to know, I can look at making them more inclusive. Many of these are not at all my accomplishments but things we've collectively picked up from HN in general. Note the self-deprecating humor.
Again, thanks!
We are looking for quick learners who enjoy working with modern software development tools in the financial and capital markets space.
Knowledge of specific frameworks or libraries is less important than a broad knowledge of software development practices, and an ability to learn.
At the NYSE, we are building customer-facing web applications with tons of referential data and many downstream systems.
Must haves:
1. Significant experience developing web applications and web sites.
2. Very solid experience with JavaScript frameworks. Particularly, React.
3. Relational database experience.
4. An understanding of automated testing and when it’s an asset and when it’s a liability.
5. Clear, concise coding skills. Your code is more often described as "clean and elegant" than "clever."
6. A healthy amount of patience for firewall/infrastructure navigation. We use modern stacks and have access to most tools, but still operate in a regulated environment.
Qualifications / Requirements: https://gist.github.com/silviogutierrez/fad88f1a917743ea5f23...
Shibboleths: https://gist.github.com/silviogutierrez/38996b3421ff946d6eb0...
Interested? Email me at silvio.gutierrez@nyse.com. Please put [Hacker News] in the subject line, with the brackets. Maybe take a look at the shibboleths in the link above and try answering a few.
There are uses cases for mutability, but it should be opt-in, not opt-out. So I'm not loving the fact that "frozen" (the mutability param for data classes) defaults to False.
- You understand meta programming python. What the type() function really does, and how it can be used. And when it should not be used.
- You understand discriminated unions, and how to use the type system to enforce exhaustive checks and other useful patterns.
- You can describe good and bad use cases for single page applications.
- You can describe why nullable types and a type system that enforces it are advantageous over type systems like Java’s.
- You can and have extracted declarative implementations out of imperative code. You know when it’s worth it and when it’s not.
- You know what the right time is to add unit tests to your code.
- You can describe a list comprehension, and have strong opinions regarding when and when not to use them.
- You know the benefits of generators and the yield statement.
- John is in many bands. We want to keep track of them. And we also want to track when he joined them. You know exactly how to model this in a relational store.
- You understand higher order functions, and sometimes secretly wish Python had more of them.
- You can describe ways in which lambda in Python is limited. And the reasoning - however flawed or not - behind it.
- You know when to use composition over inheritance.
- You understand the article “What Color is Your Function?” and can discuss it with us.
- You think comments are a last resort for documenting an algorithm.
- You can describe a pure function. Bonus: you can explain referential transparency. Even I can’t.
- You hate repeating yourself. DRY not WET.
- You understand the illusion of complexity and why simplicity is always better.
- You know the different types of automated testing there are, and when to use each.
- You have strong opinions on handling nested resources in REST and can espouse all the benefits of your take.
- You have strong opinions on handling versioning in REST and can espouse all the benefits of your take.
- You know what a shibboleth is.
We are looking for quick learners who enjoy working with modern software development tools in the financial and capital markets space.
Knowledge of specific frameworks or libraries is less important than a broad knowledge of software development practices, and an ability to learn.
At the NYSE, we are building customer-facing web applications with tons of referential data and many downstream systems.
Must haves:
1. Significant experience developing web applications and web sites.
2. Very good grasp of Python 3.5+ or TypeScript. Both are a plus.
3. Some knowledge of the other language listed above.
4. Willingness to work with both ecosystems.
5. Relational database experience, ideally PostgreSQL.
6. An understanding of automated testing and when it’s an asset and when it’s a liability.
7. Clear, concise coding skills. Your code is more often described as "clean and elegant" than "clever."
8. A healthy amount of patience for firewall/infrastructure navigation. We use modern stacks and have access to most tools, but still operate in a regulated environment.
Nice to haves:
1. Understanding of formal methods
2. Bash and vi fu.
3. Mypy and static typing experience in Python.
4. React experience.
5. Django experience.
6. Static typing experience in other languages: Java, C++
7. API design
8. Rust experience
Interested? Email me at silvio.gutierrez@nyse.com. Please put Hacker News in the subject line. Maybe even take a look at the shibboleths in the sub-comment below and try answering a few.
- You understand meta programming python. What the type() function really does, and how it can be used. And when it should not be used.
- You understand discriminated unions, and how to use the type system to enforce exhaustive checks and other useful patterns.
- You can describe good and bad use cases for single page applications.
- You can describe why nullable types and a type system that enforces it are advantageous over type systems like Java’s.
- You can and have extracted declarative implementations out of imperative code. You know when it’s worth it and when it’s not.
- You know what the right time is to add unit tests to your code.
- You can describe a list comprehension, and have strong opinions regarding when and when not to use them.
- You know the benefits of generators and the yield statement.
- John is in many bands. We want to keep track of them. And we also want to track when he joined them. You know exactly how to model this in a relational store.
- You understand higher order functions, and sometimes secretly wish Python had more of them.
- You can describe ways in which lambda in Python is limited. And the reasoning - however flawed or not - behind it.
- You know when to use composition over inheritance.
- You understand the article “What Color is Your Function?” and can discuss it with us.
- You think comments are a last resort for documenting an algorithm.
- You can describe a pure function. Bonus: you can explain referential transparency. Even I can’t.
- You hate repeating yourself. DRY not WET.
- You understand the illusion of complexity and why simplicity is always better.
- You know the different types of automated testing there are, and when to use each.
- You have strong opinions on handling nested resources in REST and can espouse all the benefits of your take.
- You have strong opinions on handling versioning in REST and can espouse all the benefits of your take.
- You know what a shibboleth is.
We are looking for quick learners who enjoy working with modern software development tools in the financial and capital markets space.
Knowledge of specific frameworks or libraries is less important than a broad knowledge of software development practices, and an ability to learn.
At the NYSE, we are building customer-facing web applications with tons of referential data and many downstream systems.
Must haves:
1. Significant experience developing web applications and web sites.
2. Very good grasp of Python 3.5+ or TypeScript. Both are a plus.
3. Some knowledge of the other language listed above. 4. Willingness to work with both ecosystems.
5. Relational database experience, ideally PostgreSQL.
6. An understanding of automated testing and when it’s an asset and when it’s a liability.
7. Clear, concise coding skills. Your code is more often described as "clean and elegant" than "clever."
8. A healthy amount of patience for firewall/infrastructure navigation. We use modern stacks and have access to most tools, but still operate in a regulated environment.
Nice to haves:
1. Understanding of formal methods
2. Bash and vi fu.
3. Mypy and static typing experience in Python
4. React experience.
5. Django experience.
6. Static typing experience in other languages: Java, C++
7. API design
8. Rust experience
Interested? Email me at silvio.gutierrez@nyse.com. Please put Hacker News in the subject line. Maybe even take a look at the shibboleths in the sub-comment below and try answering a few.
- You understand meta programming python. What the type() function really does, and how it can be used. And when it should not be used.
- You understand discriminated unions, and how to use the type system to enforce exhaustive checks and other useful patterns.
- You can describe good and bad use cases for single page applications.
- You can describe why nullable types and a type system that enforces it are advantageous over type systems like Java’s.
- You can and have extracted declarative implementations out of imperative code. You know when it’s worth it and when it’s not.
- You know what the right time is to add unit tests to your code.
- You can describe a list comprehension, and have strong opinions regarding when and when not to use them.
- You know the benefits of generators and the yield statement.
- John is in many bands. We want to keep track of them. And we also want to track when he joined them. You know exactly how to model this in a relational store.
- You understand higher order functions, and sometimes secretly wish Python had more of them.
- You can describe ways in which lambda in Python is limited. And the reasoning - however flawed or not - behind it.
- You know when to use composition over inheritance.
- You understand the article “What Color is Your Function?” and can discuss it with us.
- You think comments are a last resort for documenting an algorithm.
- You can describe a pure function. Bonus: you can explain referential transparency. Even I can’t.
- You hate repeating yourself. DRY not WET.
- You understand the illusion of complexity and why simplicity is always better.
- You know the different types of automated testing there are, and when to use each.
- You have strong opinions on handling nested resources in REST and can espouse all the benefits of your take.
- You have strong opinions on handling versioning in REST and can espouse all the benefits of your take.
- You know what a shibboleth is.
We are looking for quick learners who enjoy working with modern software development tools in the financial and capital markets space.
Knowledge of specific frameworks or libraries is less important than a broad knowledge of software development practices, and an ability to learn.
At the NYSE, we are building customer-facing web applications with tons of referential data and many downstream systems.
Must haves:
1. Experience developing web applications and web sites.
2. Very good grasp of Python 3.5+ or TypeScript. Both are a plus.
3. Some knowledge of the other language listed above.
4. Willingness to work with both ecosystems.
5. Relational database experience, ideally PostgreSQL.
6. An understanding of automated testing and when it’s an asset and when it’s a liability.
7. Clear, concise coding skills. Your code is more often described as "clean and elegant" than "clever."
8. A healthy amount of patience for firewall/infrastructure navigation. We use modern stacks and have access to most tools, but still operate in a regulated environment.
Nice to haves:
1. Understanding of formal methods
2. Bash and vi fu.
3. Mypy and static typing experience in Python
4. React experience.
5. Django experience.
6. Static typing experience in other languages: Java, C++
7. API design
8. Rust experience
Interested? Email me at silvio.gutierrez@nyse.com. Mention that you saw this on HackerNews and what position you're applying for.
https://entertainment.theonion.com/time-announces-new-versio...
Sadly, it's video-only. Couldn't find an article.
Erythritol is actually 70% as sweet as sugar. So you actually need to supplement it with something else to match sugar.
Any cursory benchmarks? Does it feel faster?
https://cityroom.blogs.nytimes.com/2008/08/08/complaints-abo...
But I avoid restaurants and places with live music unless the sole purpose is dancing. They advertise live music as a feature but sadly I treat it as a negative.
Maybe it's just me, but I have never been at a restaurant/bar playing live music where I've thought "this is playing at exactly the right level of volume."
It's always set to 11. One louder than necessary.
In flow, getOptions() wouldn't be in the transpiled code at all.
Imagine the body of getOptions as an extremely expensive computation. Some prime calculation. But you only want its return type. In flow comments, you can get it.
In the approach of your snippet, you could get it, but it will execute the full function with the full price.
But in your TS example, the code would execute. Not in the Flow example, where it's just an annotation.
There are hacks and other approaches, documented here:
But jeans for comfort? Maybe I'm the only one, but I find pants infinitely more comfortable. Even wool dress pants.
And in the summer, jeans barely breath at all.
Not unlike "egregious" [1].
Relationships must be done manually, including joins, traversing, and many to many.
Sometimes doing:
w = Widget.objects.get(pk=2) w.category.author.name
Is just all you need. And Django makes that trivial.
If a TypeScript ORM with automatic schema migrations and decent expressiveness comes around, I'd be willing to give NodeJS another shot.
But so far, nothing comes even close to the productivity of Django + ORM + Django Rest Framework. For your typical CRUD app, this will walk circles around any current JS solution. Even if the lack of static typing eventually becomes a bit of a pain.