1000 results for “isa_adorable”
https://www.lovenba.com/1821763/ Why Portland’s 4-Guard Rotation Is A Nightmare For The NBA ##JrueHoliday ##micahnoori ##ScootHenderson ##toumanicoumara #Blazers #CBA #chinesebasketball #dametime #DamianLillard #deni #deniavdija #donovanclingan #NBA #NorthwestDivision #Portland #PortlandTrailBlazers #PortlandTrailBlazers #RipCity! #shaedonsharpe #Timelord #TrailBlazers #WesternConference #yanghansen
1/2 Red Ragtop ‘Stangs on my block plus a retro Bug.
This one is the first gen of the 60s redesign, that sparked the muscle car battles of the oughts. Mine is this generation, with the large headlights.
This is a GT not just badged-up (I’m judging by the dual exhaust though it could be a costly aftermarket). The rear stripes are added I think. It’s the same year as mine bc of the spoiler. Those clip-on floods are wild!
#FordMustang #Mustang #MuscleCar #NYC #ragtop #convertible #Blaze
New! Xteink X4 Pocket Reader: A Review
The Xteink X4 Pocket Reader is a stand alone ebook reader that is just slightly bigger than a credit card. Here, Phil goes through the features of the device, how to get your books onto it, and sums up if the X4 if the right ebook reader for you.
https://www.hashbangcode.com/article/xteink-x4-pocket-reader-review
#review #tech #hashbangcode
European Blue Economy report 2023: economic crisis takes a toll but doesn’t stop the growth
The European Blue Economy report is a compass to help decision-makers and stakeholders navigate the waters of the…
#Economy #bioeconomy #Biotechnology #EconomyofEU #EconomyofEuropeanUnion #EconomyoftheEU #EconomyoftheEuropeanUnion #EUeconomy #Europe #fishingindustry #maritimeeconomy #shipbuilding #windenergy
https://www.europesays.com/3331620/
We're less than a week away! The Book Bazaar is a celebration of #indie #publishing, so go help make some amazing books and projects come to life! Plus there's free stuff...
#fantasy #sciencefiction #lgbtqia #horror #poetry
https://www.backerkit.com/c/events/the-book-bazaar-2026/coming_soon
RE: https://infosec.exchange/@flyingpenguin/117485961581578272
Yeah, Claude is great for busywork. But in the end, there is a self-correcting reality
What sparked my interest in the topic was learning that the leading cause of death in Canada is cancer. In the US, it's heart disease. As it turns out, there is a relationship between cancer mortality and latitude, as well as position in time zone:
Latitude of Residence and Position in Time Zone are Predictors of Cancer Incidence, Cancer Mortality, and Life Expectancy at Birth [2011]
https://www.tandfonline.com/doi/abs/10.3109/07420528.2010.541312
However, CVD mortality risk also increases with higher latitude, but perhaps access to healthcare mitigates CVD risk better than cancer risk?
Then there's geomagnetic effects to consider:
Correlations between geomagnetic field and global occurrence of cardiovascular diseases: evidence from 204 territories in different latitude [2023]
https://doi.org/10.1186/s12889-023-16698-1
#CircadianRhythym #cancer #Cardiovascular #chronobiology #sleep #geomagnetic
RE: https://kolektiva.social/@helynbasil/117496077092206168
‼️FAMILY IN SERIOUS NEED‼️
⭕️ HILEN @helynbasil IS A YOUNG WOMAN WITH HOPES & DREAMS. HILEN & HER SISTER WOULD LIKE TO CONTINUE THEIR EDUCATION. SADLY, FEW DONATIONS HAVE BEEN RECEIVED.
THIS FAMILY ALSO HAS SERIOUS MEDICAL NEEDS‼️
Please help by sharing & or donating.
https://gaza-verified.org/people/@hely[email protected]/
#Gaza #Palestine #humanrights #humanity #savegaza #helpgaza #education #university #fedihelp #fediforgaza #gazafamily #mentalhealth #boost #boost4reach
Priority Bicycles představila elektrokolo E-Sauce pro městské ježdění a lehčí terén https://bikerumor.com/priority-bicycles-e-sauce-is-a-versatile-low-maintenance-single-speed-e-klunker/
Daniel Humm’s new restaurant, Humm, is ‘a labour of love’
Follow us Add us as a preferred source on Google Newsletter Subscribe to our newsletter Not too long…
#London #Britain #UnitedKingdom #UK #GB #England #Headlines #News #Europe #EU #EatandDrink #Londonrestaurant #Newrestaurant #NewrestaurantLondon #Newrestaurantopenings #NewrestaurantopeningsLondon #restaurant
https://www.europesays.com/gbr/london/44517/
We’re into year 2 into Apple discovering that covering app content with random floating UI elements is a shit idea that they never should have done
https://www.macrumors.com/2026/10/25/apple-wants-to-fix-safari-on-iphone-duo/
https://www.europesays.com/news/91193/ Trump’s Midwest Approval Rating Is a Warning Sign for GOP #Approvalrating #DonaldTrump #GOP #Headlines #midterms #midwest #News #poll #TopStories #TrumpApprovalRating
M5UnitUnified (0.6.4) for esp32 by M5Stack
➡️ https://github.com/m5stack/M5UnitUnified
M5UnitUnified is a library for unified handling of various M5 units products.
David Rubenstein can't stop saying and doing silly things. His latest verbal outburst is a cardinal sin at the MLB office. And #Orioles fans may pay the biggest price. Especially those waiting for another All Star Game in #Birdland
https://www.si.com/mlb/orioles/onsi/orioles-owner-david-rubenstein-s-recent-remarks-are-likely-to-cost-o-s-fans-the-most-01m5sygeegj1
Well I had a chance to play with Reverse Engineer Anything (#rea) on one of my old #atarist #demos and this is the result: https://gitlab.com/stsquad/amazing
I was able to give the tool a random backup @fenarinarsa managed to extract from my old ST disks but I didn't have the original graphics. So the code commentary is close to verbatim from what my teenage self wrote.
Obviously building Atari binaries is a pain so this builds with gnu m68k-cross-binutils.
They put a spell on us: Black musicians and spooky tunes for Halloween
Black Music Sunday is a weekly series highlighting all things Black music, each featuring its own vibrant soundtrack.
https://www.europesays.com/people/278956/ Zelenskyy Mocks Trump Envoy’s Claim Putin Is A ‘Humanitarian’ #DonaldTrump #Russia #Ukraine #VladimirPutin #VolodymyrZelenskyy
[Blog Archive] How to install Omnissa App Volumes In-Guest #VHD - pt.1
Omnissa App Volumes In-Guest VHD is a solution designed to ensure a permanent storage area for Instant Clone VDIs using a deployment method that differs from typical storage-based vSphere deployments.
Working with In-Guest VHDs allows administrators to maintain a portable http://rviv.ly/cK7Z5I #appvolumes #inguest #instantclones #vdi
https://www.europesays.com/unitedstates/65904/ Trump’s Midwest Approval Rating Is a Warning Sign for GOP #ApprovalRating #DonaldTrump #GOP #midterms #Midwest #Poll #Polls #PublicOpinion #TrumpApprovalRating
https://www.europesays.com/conflicts/51099/ Qatar says reopening Strait of Hormuz ‘unconditionally’ is a priority | US-Israel war on Iran News #AsiaPacific #China #Iran #MiddleEast #News #Qatar #StraitOfHormuz #UnitedStates #US&Canada #USIsraelWarOnIran
There will come a time
(soon)
#Americans will realize that
ALL 'economic structure' that gravitates around #Musk
is a > scam.
Scam protected by #banks
(that have lent money)
by the #Trump administration.
BILLIONS of investors' savings burned,
a big 'slice' of Trump's 'huge' economy
a fraud.
The tragic thing is that MILLIONS of investors will realize
they have burned their savings.
We #Europeans already know this
This is why we 'detach' ourselves before the collapse.
Continuing with the NAND Flash connected to the Raspberry Pico.
There is a good example code from Adafruit for thr RP2040 to transform it into a USB mass storage device, using the Adafruit Tiny USB stack. The example code is running from SRAM (8kByte to be exact). The code can be found here: https://github.com/adafruit/Adafruit_TinyUSB_Arduino/blob/08c7dabed48b5ab92839289f58191b3f04f48fb0/examples/MassStorage/msc_ramdisk/msc_ramdisk.ino
The idea is to simply rewrite the code to use my NAND Flash.
Sunday Reviews
You Better Be Lightning by Andrea Gibson
You Better Be Lightning by Andrea Gibson is a queer, political, and feminist collection guided by self-reflection.
The poems range from close examination of the deeply personal to the vastness of the world, exploring the expansiveness of the human experience from love to illness, from space to climate change, and so much more in between.
One of the most celebrated poets and performers of the last two decades, Andrea Gibson’s trademark honesty and vulnerability are on full display in You Better Be Lightning, welcoming and inviting readers to be just as they are.
My Thoughts
You Better Be Lightning by Andrea Gibson is a collection of poetry that I borrowed from the library last month.
Gibson’s poetry is considerably more down-to-earth than what I typically read. That isn’t a bad thing. In fact, I found the collection quite enjoyable.
One thing that particularly impressed me was Gibson’s relationship with rhythm. As a poet myself, I can appreciate the skill involved. There is a natural cadence to the writing that makes it easy to hear the poems being performed, even when you’re simply reading the words on a page.
Gibson’s background in spoken-word poetry really comes through in the work.
Another strength of the collection is its accessibility. I would especially recommend this collection to queer readers. Both the representation and the way Gibson expresses queer experiences make it a worthwhile read.
Ultimately, You Better Be Lightning is a collection I would recommend, even to people who don’t ordinarily read poetry.
You don’t have to share a poet’s particular style to appreciate their craft, and Andrea Gibson certainly demonstrates that here.
#Bookreview #libraryBook #Newsletter #poetry #poetryCommunity #poetryIsNotDead #WomenPoets
Small coding choices can make software easier to understand and maintain. One example in C# is how we initialize string properties in DTOs.
A DTO —Data Transfer Object— carries data between parts of an application. For example, it might carry a customer’s name from an API request into the application.
Consider these two approaches:
public sealed class CreateCustomerDtoWithNull
{
public string Name { get; init; } = null!;
}
public sealed class CreateCustomerDto
{
public string Name { get; init; } = string.Empty;
}
Both avoid the compiler warning about an uninitialized non-nullable property. Both initial values can be rejected by FluentValidation.
But they create different starting states.
For required text fields where missing and empty values are treated the same, I prefer string.Empty: it gives the property an actual string value without suppressing a compiler warning.
The difference becomes clearer when we look at what each declaration means.
With nullable reference types enabled, string expresses the intention that a property should not contain null.
However:
public string Name { get; init; } = null!;
initializes that property with null.
The ! suppresses the nullable warning. It does not create a value, check anything at runtime, or guarantee that something will replace the null later. Microsoft explicitly documents that the operator has no runtime effect. Microsoft: null-forgiving operator.
With:
public string Name { get; init; } = string.Empty;
the property starts with "": an actual string containing zero characters. It is different from " ", which contains a space. Microsoft: String.Empty.
This makes the initial state more consistent with the declared type. We have a string; we still need to check whether its content is acceptable.
“FluentValidation can catch both” is correct.
For example:
using FluentValidation;
public sealed class CreateCustomerDtoValidator
: AbstractValidator
{
public CreateCustomerDtoValidator()
{
RuleFor(x => x.Name)
.NotEmpty()
.WithMessage("Name is required.");
}
}
For strings, NotEmpty() rejects all of these:
Value Result
null Rejected
"" Rejected
" " Rejected
"Maria" Accepted
This behavior is documented by FluentValidation and can also be checked in its implementation. FluentValidation documentation, NotEmptyValidator source code.
The preference for string.Empty therefore concerns the object’s starting state and the clarity of the code.
It separates two responsibilities:
Also, validation does not fill in the missing name. It reports the problem so the application can reject the request.
In an ASP.NET Core application using Clean Architecture, a straightforward execution flow is:
API receives the request
→ DTO is created
→ Application validates the input
→ Domain creates a valid customer
→ Infrastructure saves the customer
The Application layer can execute validation before continuing:
await validator.ValidateAndThrowAsync(dto, cancellationToken);
// Continue with customer creation only after validation succeeds.
The API must then translate validation failures into an appropriate response, such as HTTP 400 with useful error messages.
The Domain should also protect its own essential rules when creating a customer. This keeps those rules effective when data arrives through another route.
Clean Architecture supports this separation of responsibilities. It does not prescribe a particular DTO initializer. Microsoft: common application architectures.
For a manager, the practical benefit is straightforward: clear starting states reduce the assumptions developers need to make. Reviewers can see what the object initially contains and where unacceptable input is rejected.
There are limits to this preference.
First, string.Empty only sets the initial value. Depending on serializer settings, an incoming JSON value such as "name": null can replace it. External input still needs validation. Microsoft: nullable annotations in System.Text.Json.
Second, sometimes null carries useful information. If a DTO should accurately represent missing input, a nullable property can be more appropriate:
public string? Name { get; init; }
The business rule can still require a name. The nullable type acknowledges that an incoming request may fail to provide one.
There are other reasonable designs too. Maarten Balliauw discourages using default! to silence warnings in JSON DTOs and discusses alternatives such as nullable properties, constructors, and required. His article supports avoiding hidden assumptions, rather than a universal preference for empty strings. Maarten Balliauw: nullable warnings in JSON models.
Ian Griffiths provides a useful counterargument: an empty string can also hide missing meaningful data if it is added simply to silence the compiler. This matters especially when objects are expected to be valid immediately after construction. Ian Griffiths: defeating the point with empty strings.
My preferred team convention is therefore:
For input DTOs where missing and empty text have the same meaning, use string.Empty and validate required content with NotEmpty(). Use nullable properties when absence matters. Use null! when there is a specific, justified initialization guarantee.
The aim is to keep the declared intention, actual starting value, and validation rules consistent—and easy for the next person to understand.
[email protected]#coding #csharp #dotnet #softwaredevelopment #software #development #engineering #inclusive #community
Why I Prefer string.Empty Over null! in Input DTOs
1. Motivation: The Problem with friend
In C++, friend is a double-edged sword. If you allow your friend to touch you inappropriately, that would be hurt. If class A befriends another class B, then everything in A becomes visible to B. friend grants all-or-nothing access — which is rarely what you actually want. You usually want your friend to only able to touch a portion of you.
Consider the following scenario. You have a Widget class that must be created through a factory, because the constructor needs to perform some privileged setup (registering with a resource manager, validating invariants, logging, and so on). But the constructor itself has to be public for std::make_unique or for the factory to reach it. The moment it is public, anyone can construct a Widget — and that is a correctness bug waiting to happen.
You might reach for friend:
class WidgetFactory;
class Widget {
friend class WidgetFactory; // grants access to EVERYTHING
public:
Widget(int x) : x_{x} {}
private:
int x_{};
};
class WidgetFactory {
public:
static std::unique_ptr<Widget> create(int x) {
return std::make_unique<Widget>(x);
}
};
int main()
{
auto w = WidgetFactory::create(42); // ok
// auto bad = std::make_unique<Widget>(42); // also ok! constructor is public, but you dont want this...
}
This "works," but it is a blunt instrument. WidgetFactory now has access to every private member of Widget, not just the constructor. As Widget grows, so does the accidental attack surface. And if you later need to grant the same narrow access to a Debugger class, you add another friend, and the surface widens again.
The question this idiom answers is:
How can I let a specific class touch only a specific portion of my class — and nothing else?
And then now let me introduce the PassKey Idiom.
2. The Classic Solution: A Nested PassKey
The core idea is to make a public function that requires an argument nobody else can construct. That argument is the passkey.
class Widget {
public:
class PassKey {
friend class Widget;
PassKey() = default; // this constructor is private
};
Widget(PassKey, int x)
: x_{x}
{}
static std::unique_ptr<Widget> create(int x)
{
return std::make_unique<Widget>(PassKey{}, x);
}
private:
int x_{};
};
int main()
{
// auto w1 = Widget{Widget::PassKey{}, 42}; // compile error! cannot access private constructor
auto w2 = Widget::create(42); // ok
}
A few things are worth calling out:
PassKey() = default; is implicitly private (it is a member of a class whose default access is private), and Widget is its only friend.Widget's constructor is public, so it satisfies the syntactic requirements of std::make_unique. But it is only callable by code that can produce a PassKey — which, in practice, means only Widget itself (or whatever Widget chooses to befriend).main, the direct construction fails to compile because Widget::PassKey is private. The only way in is through create.This is a clean, zero-boilerplate solution for a single class. But it does not scale. If you have Widget, Gadget, and Sprocket, you must replicate this nested-class boilerplate in every one of them. Worse, the authorized "friend" is baked into the nested definition, so if you want Widget's constructor callable by both a Factory and a Debugger, you either befriend both inside PassKey or duplicate the pattern. How to solve this? we can use a template!
3. Scaling Up: The Templated PassKey
The templated PassKey decouples the mechanism from the class it protects. You define it once, and any class can use it:
template <typename T>
class Passkey {
friend T; // only T can construct a Passkey<T>
Passkey() = default; // private: no one else can create one
};
Now the authorized class can create a passkey, and unauthorized code cannot:
class WidgetFactory;
class WidgetDebugger;
class Widget {
public:
// Public constructor, but only callable by whoever can make a Passkey<WidgetFactory>
Widget(Passkey<WidgetFactory>, int x)
: x_{x}
{}
// A separate, narrower door for the debugger
void dump(Passkey<WidgetDebugger>) const { /* ... */ }
private:
int x_{};
};
class WidgetFactory {
public:
static std::unique_ptr<Widget> create(int x) {
return std::make_unique<Widget>(Passkey<WidgetFactory>{}, x);
}
};
class WidgetDebugger {
public:
void inspect(const Widget& w) {
w.dump(Passkey<WidgetDebugger>{});
}
};
int main()
{
auto w = WidgetFactory::create(42); // ok
WidgetDebugger{}.inspect(*w); // ok
// auto bad = std::make_unique<Widget>(Passkey<WidgetFactory>{}, 1); // error
// WidgetDebugger{}.inspect(...) can't call Widget's ctor; Factory can't call dump()
}
The design now has two key properties:
Widget's constructor admits only WidgetFactory. Widget::dump admits only WidgetDebugger. Neither can use the other's door. No friend grants blanket access.Passkey<T> is written once and works for any number of classes. There is no nested-class boilerplate to copy.A subtle but important point: std::make_unique cannot construct the Passkey for you. The authorized class must explicitly pass Passkey<WidgetFactory>{} into the constructor call. That is by design — make_unique is not the privileged party; the caller is.
Improvement you can made if you are using C++20
C++20 does not fundamentally change the PassKey mechanism. There is no concept that replaces it, because concepts constrain types, whereas PassKey constrains who can produce a token. The two compose nicely, though: if you are building a generic system where the set of authorized callers is itself parameterized, you can write
#include <type_traits>
// Marker: only types deriving from this may be a Caller.
struct Privileged {};
// Passkey<T> only exists if T is privileged.
template <typename T>
requires std::is_base_of_v<Privileged, T>
class Passkey {
friend T;
Passkey() = default;
};
class Widget {
public:
Widget(Passkey<class Factory>, int x) : x_{x} {}
private:
int x_{};
};
// Factory opts in — so it can make a Passkey<Factory>.
class Factory : Privileged {
public:
static Widget create(int x) { return Widget(Passkey<Factory>{}, x); }
};
// Sneaky does NOT opt in — so Passkey<Sneaky> won't compile.
class Sneaky {
public:
// Widget w{Passkey<Sneaky>{}, 1}; // error: constraint not satisfied
};
That's the whole idea. Widget's constructor is public, but the only way to call it is to hand it a Passkey<Factory> — and only Factory can construct one, because Factory is the friend. The requires clause adds one extra guarantee: you can't even write Passkey<X> unless X derives from Privileged, so unauthorized types fail at the template level instead of at the friend level.
4. Group Permissions: Variadic Friends (C++26)
The templated PassKey has one remaining friction point. Suppose a single function should be callable by several authorized classes — say a Factory, a Debugger, and a Serializer. Before C++26, you cannot write friend Ts...; expanding a parameter pack in a friend declaration is ill-formed. The workarounds are ugly: manual overloads, a combined passkey type, or a chain of nested friends.
C++26 fixes this with variadic friends (P2893R3). You can now expand a pack directly:
#include <iostream>
// C++26: variadic friends — one passkey authorizes a whole pack of types.
template <typename... Ts>
class Passkey {
friend Ts...;
Passkey() = default;
};
class Factory;
class Debugger;
class Serializer;
class Widget {
public:
// Only Factory, Debugger, and Serializer can call this.
void secretInit(Passkey<Factory, Debugger, Serializer>) {
std::cout << "Widget initialized\n";
}
};
// Each authorized type can build the passkey — and thus call secretInit.
class Factory {
public:
void make(Widget& w) { w.secretInit(Passkey<Factory, Debugger, Serializer>{}); }
};
class Debugger {
public:
void poke(Widget& w) { w.secretInit(Passkey<Factory, Debugger, Serializer>{}); }
};
class Serializer {
public:
void save(Widget& w) { w.secretInit(Passkey<Factory, Debugger, Serializer>{}); }
};
// Not in the pack — cannot construct the passkey.
class Intruder {
public:
// void tryIt(Widget& w) { w.secretInit(Passkey<Factory, Debugger, Serializer>{}); }
// ^ error: Passkey ctor is private; Intruder is not a friend.
};
int main()
{
Widget w;
Factory{}.make(w); // ok
Debugger{}.poke(w); // ok
Serializer{}.save(w); // ok
}
This makes the "group permission" case a one-liner and removes the need for the combined-type hack. It is a small language feature, but for the PassKey idiom it is a meaningful ergonomic win: the passkey now expresses "these N types, and no others" directly in the type system.
5. Performance and Trade-offs
Runtime cost
In theory, passing an empty object by value could cost a register or a stack slot. In practice, in optimized builds, it is a zero-cost abstraction. Because Passkey has no data members and the parameter is unnamed, the optimizer elides it entirely at -O1 and above. There is no runtime check, no branch, no token comparison — the entire mechanism lives in the type system and disappears in the emitted code.
The one caveat
If the protected function is not inlined (defined in a separate translation unit, and LTO is disabled), the calling convention may still require passing a byte for the empty class to satisfy the ABI. This is a minor, usually irrelevant cost. For header-only or inlined usage — which is the common case — there is no overhead at all.
Compile-time cost
Slightly more template instantiation (one specialization per authorized type), and slightly longer function signatures. This is the real price, but it is usually trivial.
Readability trade-offs
Widget(Passkey<Factory>, int) is visually heavier than Widget(int).
6. Idiomatic Usage and Best Practices
void foo(Passkey<T>), not void foo(Passkey<T> key). The unnamed parameter signals "this is a token, not data — it carries no information and is never used in the body."explicit if you are being defensive. explicit Passkey() = default; is not strictly required — the private access already blocks unauthorized construction — but it guards against brace-initialization surprises and makes intent explicit. It is harmless and recommended for older-standard compatibility (C++17 or earlier).// only Factory may construct Widget — saves future readers from reverse-engineering the idiom.
8. Summary
friend is all-or-nothing; the PassKey idiom gives you per-function, per-caller access control.Passkey<T> is the idiomatic production form.friend Ts...) turns "group permissions" into a one-liner, removing the last piece of friction.Happy coding!#code #cpp #programming #softwareengineering #software #coding #development #engineering #inclusive #community
Deep dive into the C++ Passkey idiom
It's not the full opt-out I'd like, but this is good progress on the #Union front in the UK. Too many companies get away with shitty working practices because their staff don't know, or perhaps don't understand what and why a union is a good thing to be a part of. This should alleviate that problem to some extent. Hopefully there's more to come.
#UKPolitics #UKLabour #WorkersRights #UKPol
Screenshot from Reddit.
#WritersCoffeeClub 25/10: Tell us about inspiration from an unlikely source.
This is a cunningly disguised variation on the dreaded ‘where do you get your ideas from’, isn’t it?
Since I rarely, if ever, know what my ‘inspiration’ is, I don’t know how to answer either question. I think my brain is some sort of fermenter, so what comes out is not easily traceable to what went in.
#books #writing #writersofmastodon