- Danish Swimming Water Quality App[1]: Native app for my iPhone that I use to check the water quality. The official one wasn't working for me, too slow and too buggy. Ultimately, it's just a JSON of public data spread on the map, very simple.
- Artwork Framer[2]: Script using Blender that converts .png into a framed 3D model. You can even adjust the frame if you want and then export it as a model to be used in VR (works even in Apple Vision)
I signed up for it, and I'm not expected to code anymore (I only do so in my free time nowadays - which actually made it even more fun!). But my company expects the engineering managers to be basically at the same level as senior/staff engineers when it comes to experience & knowledge. Part of my work is coaching people, which now I cannot really do in many ways.
But I'm on a good end anyways, since I have a team of people that I know I can trust with things. So I'm here mostly to find out what would be the best way for me to approach this. Thanks for all the advice!
Very blunt, I appreciate that. Though, engineering leadership is certainly different than other types of leadership. Managing through example was my current way of working. I'd be collaborating with engineers, and try to coach them when I could, or sponsor them when I couldn't (provide with either internal or external coaching).
I didn't mention that I'm coding in my initial post, and the reality is that I currently don't code at my job. So while I appreciate your answer, it doesn't really apply to my case, or my question.
On the opposite, I find that sharing code across full stack is becoming overrated. The reason I'm saying this is because that often leads to some very messy dependencies, and maintaining that codebase can become really difficult if you're not very careful.
Additionally, I found that in some teams, people would use some backend code on the frontend, resulting in some security vulnerabilities (server-side logic running on FE instead of BE). Instead, now that we have backend (Go) & frontend (TS) teams at my work, both teams consider the best practices for each environment with more focus. You could say that the same people do that with the same stack, but in my experience, if you allow people to put more focus on the one component they're building, they'll just build it better than when they have a plethora of other dependencies to consider.
The main problem could be talent, as if you have specialised people, you always have to hire for both of these positions (or train your people in either direction internally). But I honestly never experienced a shortage of people. It's more of a problem if you have a shortage of money, at which point, you should just use whatever you can build with the quickest to keep your business afloat.
With Swift UI & Jetpack Compose, I found it really easy to make a jump from React to either platform. The mental model is pretty similar to React in both. Sure, Android is still a lot of boilerplate (in my opinion), but Kotlin & Swift are also relatively easy to get into, especially if you happen to have some OOP experience.
There really should be a way to tell browsers up front about these things like changing box model for all elements, so that it's not forced to apply it for each element on the page one by one.
While I'm sure there are many optimisations already in place, at least we could avoid this anti-pattern that everybody's doing on web these days.
That's why you can use fixed library versions to make sure nothing changes. If you need to update something in the library, you can apply a patch and keep going.
> And this might mean asking to play video games with them.
I double this. It breaks so many barriers to just embrace the hobby and go along with it. Once the barriers are down, you'll get to know the person behind that face much much better.
I've started building something like the last idea. I call it very simply Daily Tasks[0]. It's by no means finished yet, but it does feel good to have an idea validated by reading about it from this blog post.
That I see as a likely outcome. Though companies may still offer an option to have a secured wallet (non-custody) for longer term storage of value. There aren't many but there are a couple of options like that out there where you give custody of the funds where you want ease of use or automation (trading, savings plans, etc.) and then have non-custody as part of the same service where you store whatever you don't want to give the custody of.
I pretty much second that this is one of the biggest flaws. I'm often assured by people invested in web3 that this is a problem that's going to be solved soon by the flood of designers entering the space, but my doubt is growing with each passing day. It seems more likely that this flaw in the system is going to persist for many years to come and very sadly, many people are going to lose a lot of money through it.
Yea, for a senior person it's possible to quickly transition into something like this from my experience. Furthermore, there's still loads of web2 type of development that needs to be done around the web3 part. That's where it's useful to know how the space works, but not strictly required for a lot of things.
In the React Native app I'm working on, I actually noticed this gesture on an iOS simulator (I didn't know about it before) and it worked well. React Native uses native components to render the UI, but it uses JS for the logic of what and where should it put the native components. I think this might be an issue in Flutter though.
I develop with React Native in my day job and I'm observing all the UI changes that are happening in the systems. So far there aren't many problems with the differences, for example in the alpha version of Android 12, Google introduced a sparkly ripple effect (they eventually removed it again). But this change was automatically propagated to all our interactive components of our React Native app, no changes to our codebase necessary. And this is the case for many other changes, since React Native uses actual native elements.
And many React Native questions are going to be the same as React questions. Generally if I have a question about some React behaviour, I wouldn't mention React Native since I'd want wider audience for answering my React question.
The beauty of this solution is that you are free to fight in other states for legislation. Instead of it being imposed to the states by the federal government even though the local population might not agree.
There's a use-case for more than a single approach. Margins and also collapsible margins are tremendously useful. In case of text of an article for example, where space changes based on other elements on the page (e. g. larger space above headings - the linked article also uses them).
In addition, if there's also CSS for `:first-child` that removes the leading margin and `:last-child` that removes the trailing, you can easily wrap them inside another component to remove the margins (or introduce a property to collapse them if you prefer). Of course, this is a bit more advanced and needs to be included in the documentation.