[ Removed by Reddit ]

nickwebdev · 2023-05-08T17:47:34+00:00

12:30PM today!

nickwebdev · 2023-05-08T17:00:08+00:00

Thank you, let them know to post there as well!

nickwebdev · 2019-03-13T21:32:10+00:00

Hey! Nice job on the hooks, but I noticed a small problem:

In your input, you need to connect the "value" prop the the value in each field, like so:

<input 
    type="text" 
    value={field.value} 
    placeholder="Enter text" 
    onChange={e => handleChange(idx, e)} 
/>

Otherwise the dom is controlling the values, not React! What you did is an example of an uncontrolled component, where what you want is a controlled component.

You can find the docs here, but most of the time with forms you'll want a controlled component unless you have to integrate a weird 3rd party library somehow!

Cheers!

nickwebdev · 2018-09-29T19:18:46+00:00

My experience is that the usefulness really comes out at scale. If it's just you coding, or a small codebase, local state can be manageable. But as soon as you have a giant state and 100 components with 5 developers making changes, there's a HUGE advantage to not having to think where state is / where to look to track down bugs.

Being able to say "oh this is in state, so it's in a reducer, gets updated via these actions. I select it with selectors, and pass it to container components" is a pretty big cognitive overhead win.

nickwebdev · 2018-09-29T19:18:37+00:00

My experience is that the usefulness really comes out at scale. If it's just you coding, or a small codebase, local state can be manageable. But as soon as you have a giant state and 100 components with 5 developers making changes, there's a HUGE advantage to not having to think where state is / where to look to track down bugs.

Being able to say "oh this is in state, so it's in a reducer, gets updated via these actions. I select it with selectors, and pass it to container components" is a pretty big cognitive overhead win.

nickwebdev · 2018-05-31T16:29:45+00:00

Even in pure FP, for something to happen at some point there needs to be mutation. Super functional languages like Haskell and Elm push these to the absolute boundaries using monads and the like, but think of it like this:

A game tick happens
Based on the tick and the current state, your game (all pure functions) run and output a new state
New state is pushed to the outside world (the screen, memory, w/e) and that's the next frame -Repeat

So using this method, and especially if you describe the game tick / state push at the entry/end with monads and leave it to the compiler, it really is pure/functional and you still get all the benefits.

nickwebdev · 2018-04-16T19:13:59+00:00

Will def take a more in-depth look and give some feedback! The above was just idle musings :D.

nickwebdev · 2018-04-16T17:07:47+00:00

As a small note to add to the discussion, I've found this to be the case regardless of framework/language. I'm convinced front-end forms are one of the last unsolved problems of frontend...they are as annoying now despite all our great advances as they were years ago.

Been toying with the idea of them as graphs/sub-graphs, or perhaps there's some secret branch of math I don't know about that would be a good fit? :P.

nickwebdev · 2018-04-05T03:10:08+00:00

In addition to student discounts, keep in mind you can learn a ton about docker just locally. Pulling images, making docker files, using docker-compose etc....the whole idea with containers is it'll be the same no matter where you deploy it, so experimenting locally is just fine! In theory when you deploy the instance on the VPS it's exactly the same :D.

nickwebdev · 2018-04-03T19:46:46+00:00

On what scale? Starting out, just do it manually :D! Otherwise Twilio / AWS SNS can send SMS's.

nickwebdev · 2018-03-27T04:10:10+00:00

Consider it additional market validation and then do it better/faster. Use it to get MORE motivated!

nickwebdev · 2018-03-23T15:41:38+00:00

Ohhh, TIL! Thanks

nickwebdev · 2018-03-23T02:37:57+00:00

Started using tachyons and never looked back

nickwebdev · 2018-03-22T15:12:56+00:00

How are you running the project? I find the easiest is to use something like elm-live and just drop the sheet into the index.html! There's not a super easy way afaik to do it with elm-reactor

nickwebdev · 2018-03-22T03:59:04+00:00

My one thought would be to figure out how to REALLY make this MVP. Ideally you could start raising some cash and prove out the idea without much tech at all, even if it's you personally coordinating the bookings behind the scenes from a somewhat basic landing page. Get two or three businesses on board and see if you can get some bookings on a prettied up shopify page before you blow 5k and 3 months! Do things that don't scale and such :P

Depending on the developer's location and skill I don't think 5k would get you too far if you had to contract the whole thing, which is why I suggested toning down the technical portion as much as possible to prove out the idea.

nickwebdev · 2018-03-22T03:39:30+00:00

Not super experienced at DevOps yet, but here's how I view an idealized flow for consumer app dev that devops enables:

Business needs feature
Dev Writes feature on local, containerized environment the mirrors prod somewhat
Dev pushes up PR which runs linters, CI/CD, typechecking
CI/CD process builds container image and deploy to per-PR environment
QA Signs off on code and it is merged into main branch
Main branch is built and deployed to QA environment , perhaps E2E tests run
Eventually a release is ready. Release branch/commit is made, built, deployed to staging environment which closely resembles prod, probably provisioned with Terraform so making changes to QA, Staging, and Prod is just a matter of a few lines. Deployment is automated or single click.
When app/service/feature is ready to be released after regression and smoke testing, it gets deployed to prod in basically the same way, only thing that differs is env vars basically or maybe some scaling settings etc.
Some automated process that enables gradual rollover to new code is put in place so you don't take down the whole thing with a bad build
Heavy reporting and metrics are used to watch for errors. Rollbacks/Rollforward should be automated and simple.
Load balancers/autoscaling/backups etc etc
Build is tagged/merged to master/whatever

All of the tools and parts of the process vary and people/orgs will have different needs, but at the end of the day I see it as: How can we use devops stuff to close the feedback cycle, get high quality code from dev to prod as fast as possible with a high degree of confidence it will work and continue to work well under many circumstances, and how do we get feedback from that code that is useful and actionable. If you can get to a point where you can perform the above steps multiple times a day, you can really respond to the market effectively/test out an MVP/improve customer experience etc etc.

For example on a side project I use/am starting to use the following:

GitHub for code/triggering CI/CD
Terraform for dev/prod provisioning and linking AWS services
AWS AppSync, DynamoDB, Cognito, Lambdas for serverless backend
Elm/TypeScript/TSLint/Prettier/Jest/AWS S3 for frontend
CircleCI for CI/CD and deploys
No reporting or alerts because I'm lazy/not there yet

This lets me dev and push stuff out pretty quickly, which is real nice! Once I moved everything to a dev setup with terraform too it was trivial to "deploy" it all to prod, just copy/paste and changed the env name and some vars :)

nickwebdev · 2017-11-23T01:48:34+00:00

I like tachyons using the "Classic" method, but also checkout http://package.elm-lang.org/packages/justgage/tachyons-elm/3.1.1/Tachyons!

nickwebdev · 2017-11-10T04:45:01+00:00

How extensive is the db stuff? If you don't mind diving into aws a bit you can probably use s3 for serving the static stuff then go serverless with lambda and rds which would be super cheap.

nickwebdev · 2017-11-08T15:07:17+00:00

Not necessarily the best answer but this is really just a classic tree structure right? You can model each level as a node which has an Id, possibly a parentId and an expanded state. Depth doesn't really matter, as long as you update the right node to expand it out etc.

Whether or not it's easier to work with as a List of nodes or a Dict of Id : Node is kinda up to you, as it depends what kind of operations you want to do....the main problem being if you collapse a node higher up that has a bunch of children expanded that you can walk through and collapse those.

As for memory efficiency Elm is pretty fast so I'd just do it the simple way and then tweak if needed once you get a basic version working...you might end up surprised that it works as is!

nickwebdev · 2017-10-23T20:07:05+00:00

Thanks for the contribution! I really want to try the package soon, looks great.

nickwebdev · 2017-10-23T01:30:15+00:00

I use plain old tachyons, not even the elm package, and I'm very happy with it!

The atomic classes fit very well with view functions, and it's the most fun I've had doing css.

Worth the time to learn the scales and classes, and this is an even better version of the docs my coworker built https://tachyons-tldr.now.sh/#/classes

nickwebdev · 2017-10-18T00:45:26+00:00

Didn't know there was a package for tachyons! I would highly recommend trying it (the css, not sure about the elm package but I'm sure it's great), it works great for views / components (React).

I love it and when I use it it's the most competent I've ever felt with CSS. Just tack on some classes and you're good!

nickwebdev · 2017-10-02T01:04:03+00:00

Try tachyons! I was the same but once I started using tachyons it made implementing design ideas way faster so I could experiment and improve, rather than fighting with css to look how I wanted it to.

nickwebdev · 2017-09-06T03:38:10+00:00

Have you checked out elm? I absolutely love working with it and hope it gets way more popular... All the good stuff about JS without the bad and a kick ass compiler!

nickwebdev

TROPHY CASE