This seems like the most honest self-assessment I have seen of one's skills.
I interviewed with Snapchat a few years ago and was asked to write a Sudoku solver. Some context: I had never played Sudoku in my life, lol. I came up with a naive (unoptimized, unrefined) solution and didn't get past their third round.
To me the main problem is that I'm always afraid to put a 5, who can not check manuals? ;-)
I'm also more and more of the opinion that (impact of projects) is more important than (current skills).
A good team member is a larger force multiplier than a single rockstar.
Rate your interest in the following:
People tend to express high interest where they want to grow, or have need.
Quite often I find that the greater skills lies in knowing when and how to check manuals rather than expecting to be a knowledge machine.
I realized one day why I behave in ways like this. It's from working in a clear-cut environment that I treat normal communication literally. Someone once commented that I 'never lie' which I understood was much more true than false but ultimately still false.
I really wish more people had some benchmark for the numbers they throw out there.
I relate so much it hurts. The industry at large seems unable to see the lost opportunity of significant investment in technical documentation.
He(?) seems to be doing a ton of interesting github repos, a great deal of informative stackoverflow answers and who knows what else.
Also, some anti-CCP stuff in the profile?
Homepage + social media links from there should give a good idea of who I am: http://www.cirosantilli.com
> Swift: I’m not an Apple person.
I'll admit, if I wasn't a professional iOS code slinger I probably never would have approached it, but at this point it's by far my favorite language to write (especially prototype) in.
The impression I got (from comments of here trying to use it) was sort of an early Mono .NET type of situation (maybe not that forked, but still). It's hard to put any effort behind learning a language when it feels like you would be a second class user. I spent way too much time and effort being the guy trying out the experimental Linux support for projects inthe late 90's early 2000's, and I have less time now, so my explorations need to be a bit more directed.
It came down to Swift or Rust for learning a new language a while back for me, and I picked Rust for the reasons above. I've yet to do anything with it (and I'll have to brush up on it yet again when I do), but at least I don't feel like I'm getting second class support from the language.
I wouldn't mind being mistaken or having this already been addressed and Swift's port to other systems is at parity with Apple's. That would be nice. I wouldn't mind spending some extra time on it then, it does look to be an interesting language.
Additionally, language features like guard/optionals/etc... allow you to deal with error states & control flow easily.
Two good videos I'd recommend on protocol-oriented development:
Protocol-oriented programming in swift (part 1): https://developer.apple.com/videos/play/wwdc2015/408/
Protocol and value-oriented programming in UIKit apps (part 2):
1. I really like the let/var system, combined with the let/guard conditional assignments. It might not work for everyone, but I write cleaner code because of it. I also love optional chaining, and I've really molded my thinking around it, as it often encapsulates large chunks of logic in a single line (essentially, do we go past here or not, based on the state of the data and whether things are set/valid). It's null checking that doesn't feel bolted on.
2. Swift has made some big changes from release to release, sometimes breaking existing code, but my largest codebase is ~70k lines, and it's taken me at most a few hours to get rolling again (FWIW, the auto updater did not work for me on 2.2->3 I believe it was). That said, the changes are worthwhile. JSON (De)/Serialization built in via the Codable protocol was a big upgrade for me, removing a vast amount of boilerplate, as well as my reliance on a 3rd party library (although big thanks to NerdRanch for FreddyJSON, it served me well).
3. Speaking of 3rd party libraries, CocoaPods has treated me well. Easy to use, not too difficult to create your own custom libraries and manage them from your own git repos.
4. I know I don't use them to their full potential, but the higher order functions:
are a real game changer. Those operations, combined with my own drive over the last ~5 years or so to write more tightly coupled, functional, code has resulted in far more maintainable, easy-for-humans-to-parse systems.
Granted, it's not all daisies and roses. I hate how it handles strings, and they can't seem to settle on an internal representation/manipulation mechanism. The safety of the whole ecosystem makes working with raw byte representations/pointers a bit of a hassle when you need to do it, but it isn't terrible/impossible.
I'm by no means an expert, and just by the nature of my work and my responsibilities (especially in other domains) I don't feel that I've had the chance to truly dig into the language for all it's worth. For instance, when I watched this video:
My mind was blown, and I didn't realize just how much I was under-leveraging the type system, and I hope to have some time to do a few personal projects to really integrate some of the more core pieces of the language into my workflow soon.
This is already huge and ranty, so if you have any pointed questions I'd be happy to take a stab.
Semi unrelated, what's up with the script tags on the profile page?
I'm not a security person though, more interested in performance stuff.
And yes, I agree with https://github.com/cirosantilli/china-dictatorship
And that speaking Chinese is much simpler than reading or writing in it. One of the simplest languages actually.
If you can only program, first choose an application that you are passionate about, that is new, hard and important, and then learn whatever you need to achieve that goal. Application first, method later.
After that, if you still want to learn low level programming... :-) use emulators + minimal examples like in my tutorials, read / step debug the source of major projects and document that somewhere, and then try to modify those major projects with useful extensions.
Fortunately most of the bios examples are using bios_* filenames. Rest of the files are very nice.
I wonder how much lower level you can go with QEMU / how much it can match real hardware.
Pull requests / links welcome ;-)
Is it to run special lab/factory equipment ? Anyone here who develops for bare metal - can you share any details?
In e.g. ARM, baremetal is potentially more useful due to embedded. But even in ARM you should just use Linux kernel / some RTOS if you can get away with it :-)
I applaude the author for the effort, in particular using images that can be booted should make it feasible to use these techniques for teaching!!
See "IncludeOS" for one representative example.
Links to minimal runnable working examples / patches welcome.