Functional programming as defined in its purest form would be ( as some others defined here ), akin to "mathematical functions as the form of abstraction". In the context of computer programming, Haskell would be the epitome of this. That being said, elements of functional programming are already available and making more head-way into imperative languages creating a hybrid imperative/functional style which I think is great. Some elements of functional programming that provide huge benefits are hard to argue against:
1. high-order functions ( as inputs or outputs ) e.g. map, reduce, filter, etc. Direct benefit is a significant reduction of code and the ability to chain operations together and compose them.
2. immutability. Direct benefit here would obviously be minimizing shared state thus reducing bugs
3. side effects: minimizing and pushing side-effects to "edges" of an application. and/or designing programs such that side effects can be mocked out. e.g. building up a Http request that can later on be executed, thus facilitating unit-testing.
4. type checking: Converting runtime errors into compile time errors ( to some degree ). again, by offloading work to the compiler, you can catch errors much earlier on.
The biggest problem w/ FP ( as I have evidenced ) is that while these things are great, when taken too far for the sake of pure FP itself, can create complex code. so there has to be a balancing act involved.
A lot of skepticism and resistance here. @tonyspiro, all the best at this. I do follow what you're doing and see the benefit of this in comparison to and also regardless of WordPress. At some point most things will be operating via APIs, and via hassle free SaaS services anyway. I, for one would not want to deal with installs, updates of any kind. It sounds like you've got some good traction that can hopefully continue. I will though acknowledge a few concerns:
1. A proper import / export tool for risk management
2. A slightly more refined message / call to action
3. Why the JS centric name/brand? Can it be used outside of NodeJS based tech stacks?
4. The price poice does seem high for small teams. You mentioned that this is normal for SaaS for some companies you listed. However, until you're established, it sounds a bit high. Can you perhaps go for a discount for the first X amount to time to entice potential customers?
1. We do offer a full data export. After you login, go to Bucket Settings > Import / Export to get a full JSON file export of your Bucket.
2. Thanks for the feedback. Anything specific?
3. Early on we wanted to be able to add dynamic content to any website server-side or client-side using NPM / React / Angular. And the domain name was available :)
4. Our target customer is teams, not individuals. And the value resonates even more with larger teams because they experience more of the pain. We've actually been told they would pay more :)
A lot of these hacker- rank like coding tests often require some extensive preparation. I've used codility (I think that was the one ), and it actually mentioned that ideally it requires at least 2-3 weeks of preparation or more.
So much this^^! Like everyone here is saying, interviewing itself is a skill, and part of that skill is how the interviewer communicates and takes part in the problem (or lack there of ). Every point you mentioned is an issue I've seen as well.
It's quite frustrating, I've submitted my portfolio of open source projects on GitHub for interviews. I specifically told the recruiters, HR personnel, hiring managers and some of the developers that the projects contain a large enough body of work to see examples of my code. These projects are quite comprehensive and not one person looked at them or mentioned them during the interviews.
Unfortunately, people in general rarely try to first understand what the candidate offers. It's more often ONLY about whether candidates uunderstand the exact way the company uses certain technology.
Knowing what good work looks like is a plus, but I wouldn't be convinced by cherry-picked successes. That doesn't tell me how much you struggled with them, how many others you failed, or how much of the work was actually yours.
I think most of your concerns could be answered fairly quickly in a conversation, though. I can look over a Github repo and check out its history and ask specific questions about changes and why they were made or why design decisions were made.
The cherry-picked successes thing is certainly a problem, though, and not just for coding. Maybe it's the candidates I've asked it but when asked "tell me about when you made a mistake in a project" they tend to answer with a strength and try to re-frame it as a weakness. "Oh, I worked too hard on this project and it made me tired" isn't a weakness. "I worked too hard on this project and that made me neglect business requirements since I was too myopic to notice" is a weakness.
Sorry if that's a tangent, it's been a pet peeve of mine since I started interviewing that not many people are humble enough or have thought enough about what their weaknesses actually are, and how that affects the success of their work.
Of those three (Kotlin, Scala, Groovy), Kotlin is by far the most pragmatic. Scala is nice, more powerful, but has a high cost when it comes to learning curve, complexity, and the library ecosystem. I'm not sure of the state of Groovy at this point after it got transferred to the apache foundation. Kotlin on the other hand strikes a nice balance in many areas.
Kotlin got a major push on Android, thanks to a stagnant Java 8 support.
With ChromeOS and Fuchsia on the game as well, it remains to be seen who will win Google's internal OS wars.
So far Android seems to be the one taking them all, though.
Outside Android I don't really see a major benefit switching whole teams away from Java, Eclipse/Netbeans and rewriting/wrapping libraries to be idiomatic Kotlin and such.
How do you define pragmatic? Apache Groovy is still under active development. We've actually started using it more for green-field development where I work.
Not the parent, but I prefer Groovy over other JVM languages because:
- supports both dynamic and static typing - it works just as well for bash level scripting as it does for full application development. For example, you can use it exactly like an interpreted language (no compilation needed).
- seamless Java integration. I know many JVM languages say that, but Groovy actually makes it one of its core features. It has a lower impedance mismatch than any other JVM language I've tried (and I try them all).
- partly because of the dynamic typing, it is able to support the most concise, powerful options in its syntax of any of the JVM languages. So you get more done with fewer, simpler lines of code
- because of the static typing and low impedance mismatch with Java, it can achieve very high performance. I was not able to get Scala to perform as well, for example, because of type conversions needed to invoke underlying Java library calls (unless you abandon idiomatic Scala).
The seamless integration is amazing. For a lot of existing Java code, it's as simple as renaming the file to .groovy. In addition to your list, some of our most used features are
- The amazing SQL library
- HTML builders (there are XML builders too)
- Literal collections (lists and maps)
> For a lot of existing Java code, it's as simple as renaming the file to .groovy
This causes the program to run in dynamically-typed mode, much sloooower, so why do it? You'd have to add @Static annotations everywhere to get anything approaching Java-like speeds. One of the Apache Groovy project managers has long since wanted to make Groovy statically compiled by default, but that's never going to happen because they're running an unofficial go-as-slow-as-possible in the official upcoming upgrade to Groovy 3.
Career sabotage, IP theft?! That's terrible. If it was a regular job it may be easy to leave or find another one, but doing a degree, especially a PhD, is a serious commitment and a lifestyle change. Outside of this, the bullying behavior is common enough across everywhere ... put a person with serious ego and control issues in a power position and they will end up a tyrant.
'Another PhD student spoke of “abuse of power” by their adviser, which included “career sabotage, IP [intellectual property] theft and more general bullying such as belittling comments, often in front of or in response to senior academics”.'
I used xamarin a few years ago for a moderately sized iOS app. It got me about 95% there. That last few percent was brutal, the app kept crashing after coming back from the contact chooser. Couldn't find a way around it, even with latest xamarin version, hot fixes. Was very unfortunate. I'm pretty skeptical of frameworks that abstract away a whole system. Hopefully, xamarin is a lot more stable and powerful these days.
People have been saying that since Xamarin came out though, myself included a few years back.
I often get the feeling that what has happened in "the last year" is that the developer saying it has gotten to know Xamarin well enough to avoid the warts.
This lessons were very informative and nicely structured. Having these type of short, concept focused lessons are perfect for serving as introductory material.
1. high-order functions ( as inputs or outputs ) e.g. map, reduce, filter, etc. Direct benefit is a significant reduction of code and the ability to chain operations together and compose them.
2. immutability. Direct benefit here would obviously be minimizing shared state thus reducing bugs
3. side effects: minimizing and pushing side-effects to "edges" of an application. and/or designing programs such that side effects can be mocked out. e.g. building up a Http request that can later on be executed, thus facilitating unit-testing.
4. type checking: Converting runtime errors into compile time errors ( to some degree ). again, by offloading work to the compiler, you can catch errors much earlier on.
The biggest problem w/ FP ( as I have evidenced ) is that while these things are great, when taken too far for the sake of pure FP itself, can create complex code. so there has to be a balancing act involved.