I’ll agree that you+ai is creating a pleasant sequence of sounds ie music. And I don’t think anyone has the right to say (within reason) what is music or isn’t.
But we might need new vocabulary to differentiate that from the act of learning & using different layers of musical theory + physical ability on an instrument (including tools like supercollider) + your lived experience as a human to produce music.
Maybe some day soon all the songs on the radio and Spotify will be ai generated and hyper personalized and we’ll happily dance to it, but I’ll bet my last dollar that as long as humans exist, they’ll continue grinding away (manually?) at whatever musical instrument of the time.
Leaving aside the veracity of that figure, if they've sold $60B of shares they don't own then they must've sold shares they borrowed in some way, and that shows up in the demand/supply. Someone (or someones) in the market would know.
A naked short on their own account would be illegal. A time-bound naked short to fulfill their role as market maker would be acceptable.
But even then, all trades are either eventually settled at some time t, or fail to settle, e.g. if the seller is not good for the shares. Any of these 2 events happening is reported outside of a single broker-dealer, i.e. public info. And to settle a trade, you will need the actual shares, that you've either bought or borrowed.
All this info, settlements, failures, stock buys & loans is visible to other parties in the market.
If your point is that the Citadel is breaking the law, and not reporting what they should, when they should, then that's a problem. But there would be so many other parties discovering it way before their annual financials are published.
Sure, but the problem isn’t that Citadel is expecting that the price will drop. The claim was that Citadel can take a short position without other parties in the market knowing, and finding out only from their annual financials.
That’s not true, because, amongst other reasons, everything you’ve listed (synthetic shares/derivatives/kicking the can down the road) can be seen by others in the market.
(Naked) Short all you want, there’s nothing wrong morally with betting in that direction. But it will be picked up.
Technologies: C#, F#, Javascript, .NET, ASP.NET, Postgres, MSSQL, React, Vue, Kubernetes, Docker, Azure
Résumé/CV: Available on request
Email: jkulubya35@gmail.com
I've got 6+ years of experience doing backend software development mainly using the dotnet stack. 4+ years building backoffice software in a stock exchange/clearing house environment (trading/clearing/settlement/payments/FIX/SWIFT/bank integration, etc.), and 2 years working on the backend of a public transit application.
I'd love to stay within the payments/finance space but I'm a quick learner and open to something new.
Not really. Best to think of .net “core” as just .net.
Anything that was in the old .net that isn’t in core today won’t ever be.
Then there’s stuff that was missing in the earlier versions of core that existed in old dotnet. Some of it they later realised was useful for newer apps or apps migrated to core. These pieces were ported over by Microsoft or replaced by 3rd party implementations (e.g. avalonia for xplat ui).
(.net core is actually officially just .net, they dropped the core from the name)
But maybe the more interesting discussion would be, why, apart from the obviously not true 30kph national speed limit, Latvia seems to be doing okay without this excess of speed?
Property accessors `.name` and methods `ElementAt(i)` can have side-effects. From just eyeballing the code, that together with the gc issue would make the compiler in my brain wary of removing the loop. I don't personally know if it's possible to convince the C# compiler that it's safe.
... I could be wrong, but I -thought- it was possible for the JIT to see there are no side effects and inline on property access (so long as the property is not a virtual call or otherwise able to devirt.)
.ElementAt() OTOH has a chance to throw in most implementations AFAIR so yeah, a bit of a moot point in this case.
Edited to add:
Actually, there -could- still be side effects in the case of .Name on a class, specifically, it's possible that .ElementAt() could return a null. I'm not sure what cases (if any) that the JIT could get around that.
OTOH, in the case of a struct, as long as .ElementAt() -doesn't- throw, .Name will always return regardless of if it is a property or field, and as part of a struct the compiler should do a good job of inlining as long as the access has no side effects (and you don't have too many fields on the struct!)
There’s no reason (other than cost and your current wealth and bank risk management) why you couldn’t get a personal loan for the full purchase price of the house, and pay the seller the cash price. You’d then see your bank account balance go up by the house’s cost, withdraw the cash and then pay the seller.
I’m not sure what bank would give a normal person that kind of money unsecured but you could secure it with e.g. another house you own. Most people don’t have a spare house, so the banks optimise the process for the everyday scenario where the buyer doesn’t need to see their bank balance go up. But money is still being created in there somewhere
From what I’ve read, the Ghanaian regulators have demanded that that specific aircraft not be flown within their jurisdiction because they don’t like the recurring issue with the fuel imbalance (…and advised that Delta flies newer planes because Ghanaians don’t like the old ones)
The FAA/EASA not being concerned by it (from what we know), doesn’t mean that there isn’t a possible safety issue to investigate.
It’s also easy to have politics and safety i.e. regulation mix in ways that aren’t so black and white. Consider the time it took for the 737 Max to be recertified in the rest of the world vs the US. Do you think that was all safety? Or some combination of safety and politics?
So no, I don’t think it’s possible to categorically state that it has nothing to do with safety.
A fuel imbalance happening twice is not a "recurring issue". It's a problem that wasn't fixed correctly. It may or may not concern you, depending on your level of knowledge about aviation, to know that when it comes to relatively minor issues like this, this kind of thing actually happens all the time — the maintenance engineer will carry out a documented series of steps to test the system, find that everything tests OK, and release the aircraft back to service. Meanwhile some intermittent fault is still present, that didn't show up during the test, and it happens again on the next flight or a few flights later. Eventually the tech log entries give enough clues to identify the problem or it happens during a test, and the issue is solved. No sane regulator would ban an aircraft for this kind of situation — a version of it happens daily worldwide, including on whatever your own favourite airline is.
Do I personally think that the 2x fuel imbalance is a problem? Nope, I’d happily get on that plane
Could this situation become a safety issue?
Yes it could.
Is it possible that there’s more to this situation than safety? Yeah, probably. Maybe they want shiny new planes on the route. But also, the passengers are paying customers with consumer rights - these are being enforced
Are the Ghanaian authorities not a sane regulator? I’ve got no reason to believe they aren’t being proper regulators. There is a possible safety issue that’s well within their mandate.
What happens when you’re dealing with regulators is if you’ve got a good relationship with them, then all the optional stuff (and some of the mandatory stuff) is optional. If not, then you’re gonna have to check every single box and then some. See Boeing in the US vs Europe.
Call it politics, call it whatever but it is what it is
I would not board an aircraft that has a history of problems with this.
Which aircraft would that be? The article describes one (yes, just one) instance of a fuel imbalance leading the crew to return to the departure airport. The reasons for the other diversions are not articulated.
FWIW your EU list shows restricted airlines not individual frames. At the end there are two airlines (Iran Air and Air Koryo) where subsets of their fleets are restricted (whole types not individual frames). With Iran Air it's likely that the restricted types are ones where sanctions make maintenance or safety compliance impossible. With Air Koryo the EU banned a bunch of unpopular Russian and Soviet types that are either way too noisy, incapable of meeting current safety standards, or are unsupported by the Russians.
Agree. Politically a government is responsible for giving its citizens a sense of security… maybe more so than actual security. Ghana and the US were both doing that in this scenario. Whether the fear is 100% reasonable or not is ultimately irrelevant. “We fixed it, no worries, go back to being productive.”
Then of course there’s the reality of them abusing fear of security to steer the herd, but I don’t want to wander down that rabbit hole.
I feel it needs to be pointed out that almost all, if not all, countries have a long history of using access to their aviation industries/airspace/airports/etc as a political tool - so Ghana is far from being alone in that sense and I don’t think it adds much to either argument
ASP.NET Core apps are actually straightforward console applications. In fact most of the application types you’ll run on .net core are configured in a main method in program.cs. The answer to your specific questions about mixing different services in one app will be some combination of the following links.
That is exactly the thing. I *do not* want to have the Sdk=...Web/Worker.
Imagine this scenario, you started a new project with the Sdk targeting Worker. Then you need that binary to also target web.
What do you do?
- If you switch the project to Sdk=...Web, you won't have the dependencies to build the worker services.
- If you keep it as Sdk=...Worker, you won't have the dependencies to build asp.net
But those are just sets of convenient defaults? You could just start with the default sdk and add the imports/targets yourself (or in practice: let the IDE do it for you.)
And
>- If you switch the project to Sdk=...Web, you won't have the dependencies to build the worker services.
Yes you will, since the worker sdk is simply a subset of the web sdk.
> You could just start with the default sdk and add the imports/targets yourself (or in practice: let the IDE do it for you.)
That's what I have been calling out. I have not had much luck in pulling in the right dependencies needed. Could not find any documentation on it. Everything relies on that Sdk=...Web thing on the official documentation.
If you’re just looking to be unblocked, use the Web SDK because you’re building and running combined web + hosted services [1]. The section linked shows the precise difference between the Web and Worker SDKs for hosted services.
If you’re looking for docs on what all the SDKs are/do, and their source code, start here [2].
If you’re looking to just add the asp net core packages/apis to your basic sdk/console project, here [3]. But note that your app build/publish probably won’t work 100% because msbuild won’t be configured to do so.
If you want to fix that manually (i.e do what the Web SDK does automatically), You can use the Web SDK props file as a starting point [4]. (Linked to in [2])
It seems well documented to me, but you’re welcome to propose new docs to the aspnet docs team. They’re very responsive [5].
Well, not much to add to what jkulubya said, but: Just use Web, then - that's what it's for and it just worksTM.
We have almost your exact scenario in production - a (Quartz.NET-based) service for background/scheduled jobs, with a web dashboard and a healthcheck API, all from a single console executable without external dependencies. And it was super straightforward to implement.
The original poster is going slightly off the beaten path and therefore has to manually compose three or four different concepts together to come to the right solution vs relying on the out of the box experience.
I, and a lot of other devs, would be able to solve this particular problem without looking up the docs but I can’t assume any knowledge on the poster’s behalf so I posted the links to the docs about the building blocks and an article showing one possible way of composing them.
The same exact problem as posed by the poster was thought of by the dotnet/aspnet teams and the pieces (apis/docs/samples) are all there, just not the default.
> I, and a lot of other devs, would be able to solve this particular problem without looking up the docs
Look through the rest of this comment thread and see how many failed attempts at solving this problem there were before two high profile members of the ASP.NET team came in (JamesNK and davidfowl).
It's not about looking up or not looking up. The criticism here is that the way the framework is laid out is not intuitive enough. It's very "different" from the rest of the industry (in this case, there are 3 potential ways of pulling in dependencies for ASP.NET). This requires a lot of time investment for its users to solve these slight one-off issues.
My question to them below was why isn't what they shared here the default. If they had done that, it would be intuitive to know that one can add other "FrameworkReferences" in a project, or know what to search for. Instead, the default is "each project can only target one SDK".
JamesNK also answered this. We started off with just nuget packages, it was beautiful for about 5 minutes until we ended up with ~300 in the default project. Then physics kicked in, slower build times, slower compilation times, slower intellisense. All of those old O(N/N^2) algorithms started to show up on profiles and we had to do something about it. That was just the practical performance side of things, then there was the customer confusion around which packages had which APIs. We offered a .NET buffet that customers hated. On top of that, the versioning got nuts. Each of those packages could in theory version independently, who is going to test all of those combinations of things? What happens when you need tot publish ~300 + packages to your server deployment because you didn't want to "install the framework"? You'd be complaining that they were too many assemblies (which people did). Amplify that by deploying these binaries to the same physical machine when running multiple .NET Core applications there (very popular for IIS setups). We pre-JIT (ready to run) the core libraries and ASP.NET to improve startup time, that makes the assemblies bigger (as they contain both native code and IL), this makes your applications bigger by default.
We got LOTS of feedback that this was all really terrible and we listened.
We did this from .NET Core's inception to .NET Core 3.0 when we pulled the plug. We set things up so that the base install/platform/framework was not composed of packages but framework references. We merged several assemblies together to get rid of some of the unnecessary layering. We invented shared frameworks so that people could install the framework once and run lots of applications using shared libraries so that:
- Customers have faster publish times as you only need to deploy your application bits, the framework can be pre-installed
- Loading the same dll on disk into multiple processes allows for more virtual memory sharing (a handy performance optimization)
- We could version the set (.NET, ASP.NET Core) as a coherent unit
- We could pre-JIT (R2R) the built in stuff so it's installed on the machine once and usable by many apps.
As for being intuitive, the default experience is to use the Web SDK. I didn't even get into SDKs but it does more than default the framework reference. It also exposes capabilities that tooling use to light up behaviors in the build and in the IDE.
PS: This stuff is harder than it looks on the surface and we spend lots of time and take lots of care designing it (making the typical tradeoffs you make when doing software engineering).
@David, thanks, and completely aligned on why we don't use nuget packages anymore.
> As for being intuitive, the default experience is to use the Web SDK. I didn't even get into SDKs but it does more than default the framework reference. It also exposes capabilities that tooling use to light up behaviors in the build and in the IDE.
It is these "does more than default framework reference" are precisely the things in discussion here. All of these hidden functionalities and dependencies are like a black box. What's the difference between what James shared here and the default Sdk=...Web, then? It's the lack of uniformity, where "ASP.NET is a first class citizen" rather than just another piece of the ecosystem that is a turn off.
Compared to other ecosystems, for example: Go, Rust, even Java for example, where everything is just code that one can pull in, and the customization is in the code, not the runtime/JVM.
It's not about if you should or should not search. It's about how often you have to do that, and how easy it is to search for what you want. It boils down to how much anti pattern a framework/ecosystem has. In this case, their default template caused me to search "dotnet core project multiple SDK", which yielded nothing, and is actually a completely wrong track.
The answer the asp.net team shared below, was instead of using the SDK attribute, use a completely different thing called FrameworkReference. Which can completely replace this SDK attribute, it seems.
Hence my question to them below was, why is framework reference not the default? Especially since it does lead to better searchability, and the template shows that one could have multiple of these per project, intuitively.
But we might need new vocabulary to differentiate that from the act of learning & using different layers of musical theory + physical ability on an instrument (including tools like supercollider) + your lived experience as a human to produce music.
Maybe some day soon all the songs on the radio and Spotify will be ai generated and hyper personalized and we’ll happily dance to it, but I’ll bet my last dollar that as long as humans exist, they’ll continue grinding away (manually?) at whatever musical instrument of the time.