Citation needed. My day to day has not changed one bit, even if I'm using Copilot and ChatGPT. I get marginally faster autocomplete and a buggy template engine. This type of comment is exactly what GP means when they say "grossly overestimated."
That you guys aren’t finding the value tells me you’re using the tool wrong and likely have already decided with prejudice, because I have primary experience that once you try to figure out how it’s useful, you’ll find remarkable utility waiting. It’s ok, man. I’m sure many folks found the computer useless too.
> Explain when pin is important in rust when dealing with asynchronous code, particularly when dealing with Box<dyn> types.
In Rust, Pin is a concept that is central to understanding the implementation of asynchronous operations. To explain why, let's first cover the basics.
Asynchronous tasks often involve future types that encapsulate a computation that will produce a value at some point in the future. These futures may need to poll other futures, which in turn might not be ready, causing them to be suspended and resumed later on. This suspension and resumption is where the Pin concept comes in.
By default, Rust allows moving types around in memory. However, when you have self-referential structures, like many of the future types in asynchronous programming, this can lead to problems. A future may hold a reference to another part of itself, and if the future is moved in memory, that internal reference may become invalid.
Pin is Rust's solution to this problem. If a type is "pinned" (wrapped in a Pin), it is a guarantee that the memory location of the value inside will not change. This means that you can safely keep references to different parts of the same structure because you know they won't move around.
Box<dyn Future> is a heap-allocated future object. Using Pin with Box<dyn Future> (i.e., Pin<Box<dyn Future>>) is common in async code because it guarantees that the future object will not be moved around in memory, making it safe to poll.
However, one should note that simply creating a Pin<Box<T>> does not mean that the T will stay put; it's also necessary to ensure that T does not move itself or its interior around. The contract of Pin is such that, once a value has been pinned, it is not allowed to move or have its memory invalidated until it is dropped. For a type to uphold these guarantees, it must be Unpin or ensure that all its operations maintain these guarantees. Most native Rust types are Unpin and therefore don't need to worry about these guarantees.
In short, Pin is important in Rust's async code as it provides a mechanism to safely handle self-referential structures, which are common in async programming. The Rust async ecosystem uses Pin to ensure that once a future begins executing (is polled), it will remain at a fixed location in memory until it has completed.
> If a type is "pinned" (wrapped in a Pin), it is a guarantee that the memory location of the value inside will not change.
Pin is a wrapper around a pointer type and disallows moving the value that that pointer points at. You don’t pin a value, you pin a reference to a value. IMHO this sentence is unclear about that.
You sorta get the right vibes from the rest of the post, but there’s a major important concept in here it explains decently but also just wrong enough that you may internalize the incorrect thing.
I agree - it’s not a panacea devoid of human involvement. I think really importantly, whatever failings the technique has, it’s reflective of humanity itself, and humans are often slightly wrong or misleading. I think confusing it’s output with that of a deterministic program is wrong - it’s much more akin to the output of a human than not.
My argument though is it’s not a freshman in college level of human failings. It’s clarity is far beyond that on many subjects, and it’s facility to “understand” is remarkable for a human let alone a computer. The fact I can interrogate it and ask it the clarifying question you bring out is beyond useful - I can dig into the specific areas of confusion I have, and often if it’s wrong I’ll cop to it unlike a human oracle.
> Clarify then: If a type is "pinned" (wrapped in a Pin), it is a guarantee that the memory location of the value inside will not change.
When we say "the memory location of the value inside will not change," what we mean is that the value that the pointer points to is guaranteed to not move in memory. This is a critical guarantee when working with certain types of data, like self-referential structs or certain async code in Rust.
Let's take an example of Pin<Box<T>>. Here's what it means:
Box<T>: This is a heap-allocated instance of T. The Box is a smart pointer that points to this heap-allocated T. Pin<Box<T>>: This is a Pin wrapping the Box. This means that the T that the Box points to is pinned. This does not mean that the Box itself cannot be moved. The Box is a pointer, and pointers can be copied and moved freely. But because we have used Pin, the actual heap-allocated T that it points to cannot be moved. This is what we mean when we say "the memory location of the value inside will not change." We're talking about the T, not the Box.
This is important when the type T has self-references, because moving T in memory would invalidate those self-references. By using Pin, we ensure that T stays put, and those self-references remain valid. This is a key part of the design of Rust's async programming model.
However, this guarantee is only upheld as long as the type T does not implement Unpin, which is a marker trait that indicates that it is safe to move a type out of a Pin. Types that are not Unpin uphold the guarantee that they cannot be moved out of the Pin once they are placed in it.
Absolutely, and I don't think every explanation has to be perfect to be useful, hence me saying "you gotta watch out" and not "fuck this tool, nobody should use it."
But I have found asking questions like "how would I ..?" or "explain ..?" can be useful as long as you don't treat like a final answer.
Programming is one of the fields were correctness actually matters in a binary way. But jobs where "sort of" or 80% is good enough can be replaced with language models.
^ Your citation, sir.
I will say that checking back a day later, I am stunned at how many smart programmer types are clearly not even close to getting how useful this tool is. For people that don't find it very helpful, to me that just means they're not asking enough of it yet. More people just need to spring for the $20/month and start asking GPT4 about any old technical subject they think they know well but about which they might also have holes in their knowledge.
It's a tool that rewards creativity, so you kind of get out what you put in. Many folks here are too young, but back when search engines were coming out, there was a phase for many people where they only knew how to treat it as a toy. Like, search for their own web page to see if it showed up; search for a question they already knew an answer to to see if it was correct. It required a bit of a mental reset; a "click"; before each person would know automatically, without reminding themselves, that they could actually search for things they didn't know.
It seems like there is something similar going on here. It's not a search engine so it's not exactly about stuff we do or don't know, but I gather that a lot of people thus far have not uncovered the advantages it actually gives them.
what is the most popular low-code/no-code solution that i could bring into an enterprise organization that can:
* read/write to/from a database
* read/write to/from a message queue
* read/write to/from a cache
* make HTTP API calls and do light ETL/logic on the request/response bodies
* OutSystems: This is a popular choice for enterprise organizations, as it provides robust low-code development capabilities. It supports integration with databases, message queues, and caches. It also allows developers to make HTTP API calls and perform light ETL operations.
* Mendix: Another popular choice for enterprise-level applications. It offers a wide range of features, including database integration, message queue handling, cache interaction, and HTTP API calls.
* Microsoft Power Apps: This platform is part of the Microsoft Power Platform, which also includes Power BI for data visualization and Power Automate for process automation. It supports data integration, including reading and writing to databases, and can make HTTP API calls.
* Appian: This is a low-code platform that allows the creation of apps that can integrate with databases and make HTTP API calls. It may require additional configuration or use of additional services for interaction with message queues and caches.
* Zoho Creator: Zoho Creator is a low-code application development platform that allows users to create custom applications with minimal coding. It can integrate with databases and make HTTP API calls, but may not natively support interaction with message queues and caches.
These aren't new and I'm still employed
The less you are just a pure code monkey and nothing more, and the more you bring added value of actually managing whole software dev lifecycle the less you are replaceable (and more senior you become with all the + and -). Chasing requests from teams that couldn't care less about your projects, navigating process hell, synchronizing with global teams, evaluating various pitches and proposals, hiring, architecture design, testing team interaction/management, internal politics and so on and on. This is still software engineer territory, albeit senior one (in my massive org I am at lowest dev position, but with salary 2 levels higher, and I get to do this and much more).
I've not seen even an attempt to put any dent on job market for those skillsets. If you are worried, ramp up your skills, thats what one should be doing regardless.
Devil's advocate: it takes visionaries at the top (CEO/management) to push for things like "that may not be not how entire projects get done today, but maybe in the future if we can get a good low-code solution that does what we want well, we could save a lot of money"
Is it a pipe dream? I don't know. That's where good execution comes into play.
And yet...
To do a few things I consider basic, you need to write nontrivial code. The two examples recently:
1. To strip non-digits from phone numbers, I needed to edit a step in the query by hand to add Text. Select. It doesn't seem to be accessible from the GUI.
2. To roll three columns up into one by replacing nulls with values from the next column, I had to write a lambda for List.Accumulate. Again, not available in the GUI, and probably not something a low-code user could hack. I think they'd have to pull it into Excel and then use a long IF formula to get there.
Low code can also be really slow when you think it's just gotta do what you want, but it doesn't, and you need to code it. However, a good platform can get the annoying bits out of the way, and the auto-preview features the platforms usually have are great.
I have templates and scaffolds for most of my reptitive work already. I feel that I'm good enough with SQL that it would take me longer to prompt an AI to write a query than it would for me to just write it.
I am open to the possibility that I'm old and set in my ways but it's been a long time since the act of writing the code has been the bottleneck in my work.
If you already can speak the language, the best it can do is provide the boilerplate.
I've rewritten portions of a legacy side project in three days, what would have taken me weeks without GPT4. And beyond the simple time estimates, there are the tasks that I just simply would not have attempted otherwise.
It's like a barely-got-a-passing-grade coding bootcamp grad with above-average-for-that-cohort Googling skills and a problem with dishonesty. Sometimes that's helpful, a little, but mostly it's a time-wasting distraction.
What it can revolutionize in its current form is mainly limited to high-automation bullshit industries. Spammers, scammers, certain kinds of marketing content that's currently farmed out to the lowest bidder, astruturfed media campaigns, targeted mass propaganda. That part, I think will be big, but will be entirely bad for society. Unless it makes another leap forward at least as big as the last one, programming's nowhere near being threatened yet, nor, even, is most writing that's not already bullshit-heavy (though it'll help make normal writing somewhat more efficient, probably)
I had a bunch of deeply-nested map/flatmap code and it rewrote it into a short pretty for-comprehension, error free. For those that haven't learned those desugaring rules cold, it's a massive help.
The cool thing about GPT is that it understands code contextually and flexibly. I can literally throw it syntax that was developed specifically for a single project, that it's almost certainly never seen before, and as long as it's similar to something it's seen elsewhere, GPT can figure it out. There's no way you're getting that from an IDE feature.
I got GPT 3.5 to transform a (simple) function into return-early style a few days ago. It didn't quite get it right, but it got the correct idea. I did this by typing "Transform this code into return-early style." With an IDE feature, I'd have to hope the developers had heard of and cared about return-early style in the first place, and then that their tool was powerful enough to realize when and how to apply it. (Highly unlikely, IMO.)
edit: In other words,
> Aren't there a relatively small, finite number of these cases that would cover a large percent of typical transformations, and do so with 100% reliability?
I believe the opposite is the case.
I’d say many people are doing similar things ?
Less jobs is not necessarily a good thing ?
The rollout of the lightbulb significantly reduced the economic potential of candlemakers, but it improved the quality of life for society overall. So, whether technological advancement is a "good thing" depends on which group you are in: the one with obsolete skills or the one that benefits from cheaper and/or better goods and services. Either way, the overall economy benefits from creative destruction.
Wouldn't it make more sense to have LLMs replace middle management? Knowing "what" to do is way easier to predict. Even the worst programmer is far better organized than the people gathering the requirements and they have to fill in the blanks all the time. These are junior programmers who know fuck all about a business yet manage to know more about the project overnight compared to management that's been there for many years!
Maybe what you're referring to is what happens in a lot of software organizations, where the "what" is often just phrased as a poorly-thought-out, loose problem, and it's actually up to the developer to come up with the specification and the implementation at the same time. But that's not what I'm talking about. What I'm saying is that if you're good at specification, your job is about to get a whole lot easier, and therefore more valuable, by using these models.
Do such programmers even exist today? I thought the Dot Com Crash wiped out any remnants of such jobs.
Every software development job now is a composite job of some sort, demanding skills and duties that were previously separated into other roles. This trend of condensing/combining roles applies to non-tech industries as well.
Specialization is still demanded, too, but the predicted future of hyper-specialization where every professional exists in a nanoscopic niche never materialized. We instead got multi-specialization due to an ever-shifting and highly unreliable labor environment.
This is why the job title of "GPT Prompt Engineer" is a joke, and will never actually exist.