#destructuralism

[dfartproject]

Aline Khieu @alinekhieu #alinekhieu #destructuralismefiguratif #destructuralism #dessin #drawing #drawings #drawingsketch #drawingoftheday #drawingart #contemporaryfigurativedrawing #drawingartist #artistofinstagram #artistoftheday #dessindujour https://www.instagram.com/p/CmpUitGr_Cc/?igshid=NGJjMDIxMWI=

[zero0virgola0]

Non me ne frega un cappero

Un cappero, il suo fiore e a sinistra, un cappero e il suo fiore destrutturati

[codemerything]

A structured way to learn JavaScript.

I came across a post on Twitter that I thought would be helpful to share with those who are struggling to find a structured way to learn Javascript on their own. Personally, I wish I had access to this information when I first started learning in January. However, I am grateful for my learning journey so far, as I have covered most topics, albeit in a less structured manner.

N/B: Not everyone learns in the same way; it's important to find what works for you. This is a guide, not a rulebook.

EASY

What is JavaScript and its role in web development?

Brief history and evolution of JavaScript.

Basic syntax and structure of JavaScript code.

Understanding variables, constants, and their declaration.

Data types: numbers, strings, boolean, and null/undefined.

Arithmetic, assignment, comparison, and logical operators.

Combining operators to create expressions.

Conditional statements (if, else if, else) for decision making.

Loops (for, while) for repetitive tasks. - Switch statements for multiple conditional cases.

MEDIUM

Defining functions, including parameters and return values.

Function scope, closures, and their practical applications.

Creating and manipulating arrays.

Working with objects, properties, and methods.

Iterating through arrays and objects.Understanding the Document Object Model (DOM).

Selecting and modifying HTML elements with JavaScript.Handling events (click, submit, etc.) with event listeners.

Using try-catch blocks to handle exceptions.

Common error types and debugging techniques.

HARD

Callback functions and their limitations.

Dealing with asynchronous operations, such as AJAX requests.

Promises for handling asynchronous operations.

Async/await for cleaner asynchronous code.

Arrow functions for concise function syntax.

Template literals for flexible string interpolation.

Destructuring for unpacking values from arrays and objects.

Spread/rest operators.

Design Patterns.

Writing unit tests with testing frameworks.

Code optimization techniques.

That's it I guess!

[zackstriker]

surrealism + abstract fiction writing sounds cool as hell dude!! is there anything especially neat you've studied lately? :0

omg i’m so glad you asked!!! i’m actually working on a novella rn that’s told in fourth person POV and it’s super hard.

as far as stuff i’ve learned: i LOVE using the “Ashamed I” pov which is when you use second person POV to tell a first person story. For example: “You had a hard day, counted three accidents on the interstate on the way to work. You didn’t see as many seagulls as normal. Lexi, your assistant, says it’s going to rain but you know she’s wrong. It hasn’t rained in weeks.” In this paragraph the “you” isn’t the you as in the reader, the “you” is a whole fleshed out character.

i’m working on destructuring the idea of the novel in a class rn and we’re reading No One is Talking About this by Patricia Lockwood (i’m actually meeting her soon bc i get to have dinner with her and introduce her at one of her readings as a part of my program) and it’s such an interesting read!! She was a poet before she wrote prose and you can really tell. i’ve never read anything quite like it!!

Anyways i’ll stop there bc i could pop off for hours and hours and hours about Weird Fiction and absurdism and avant-garde literature.

[codomars]

Day 30 — 35/ 100 Days of Code

I learned how to handle JavaScript features (default parameters, spread, rest, and destructuring).

And I finally reached the DOM chapeter, 'The Document Object' which contains representations of all the content on a page. I'm still discovering its methods and properties.

So far, I've learned about the most useful ones: getElementById(), querySelector, changing styles, manipulating attributes, and the append method.

I'm doing some silly practice exercises just to get more familiar with the DOM methods. The more I progress in my course, the more fun things seem to get. I'm really excited to start building stuff with code and combining HTML, CSS, and JS all together.

[lazar-codes]

06/07/2023 || Day 46

I woke up this morning completely exhausted and my brain wasn't working. It wasn't until 4pm when I decided to just go on a walk for an hour that I felt ok. Dunno what's up with that...

Remember how I said yesterday that I'd get started on React? Well, I started to watch a video and the person went over the pre-requisites for learning React (i.e. what Javascript concepts you need to know), and I basically had to learn a lot of concepts related to ES6 such as arrow functions, modules, destructuring objects, spread operators, and other stuff, and I realized I knew none of those. So...I watched another video that went over all that, and while the video itself was only an hour long, it took me about 2-3 hours to get through it because I was constantly pausing the video and writing notes.

Anyways, this wasn't the first video by this guy that I've watched and I really like watching his videos for longer introductions to topics, so here's a link:

[silverynight]

What would happen if Tanjiro works in the butterfly mansion as a medical assistant?What if he offers to give destructuring and relaxing massages for the sore muscles of demon slayers?

He becomes part of the butterfly staff after being rescued by Amane and her girls; Nezuko lives there as well, but she's always in a dark room and only comes out at night. All the butterfly girls are really fond of both Kamado siblings.

However, as soon as he starts working there he gets himself a lot of suitors; he has no idea but a lot of slayers and kakushi develop a crush on him.

There's always a line of people begging Tanjirou to tend to their wounds and give them massages for sore muscles because not only Tanjirou is pretty good at it, it also means they get to be touched by him.

Things are very peaceful for a while because even though sometimes the slayers and kakushi fight over him (nothing serious) and most of them try to ask him out, they're (most of the time) very calm about it, just waiting for Tanjirou to choose one of them.

However, that's when the Pillars meet him, they don't usually interact with other members of the Corps a lot because they're really busy and rarely get hurt (when they're not fighting upper moons) but one day they see him on their way to a hashira meeting.

Tanjirou beams at them (because he doesn't know enough to be afraid or intimidated by them) and tells them (as he does with everyone) that he's really grateful for their hard work.

That's when everything goes to shit, at least for the slayers and kakushi because the hashira notice what's going on immediately let everyone know that Tanjirou is off limits from that moment on.

Which is... not fair.

[dfartproject]

Aurélie Richard @photoart_ar #photoart_ar #analogcollage #collage #collageartwork #collageart #figurative #figurativeart #destructuralismefiguratif #destructuralism #artist #artwork https://www.instagram.com/p/CoIepFsrM_A/?igshid=NGJjMDIxMWI=

[itsjunetime]

rust structs you can instantiate at compiletime or runtime

i ran into a problem recently where I wanted a struct in rust that I could create at runtime or compile time, but it needed to own data that was traditionally allocated on the heap (String, Vec, etc), and that's not possible to instantiate at compile time. rust has compile-time analogs for those (&'static str, &'static []), but those can't be created at runtime (yes, I know about Box::leak and mem::transmute, but that's evil).

the initial clunky but seemingly rusty solution: enums! Just use something like

StringWrapper { String(String), StaticStr(&'static str) }

but that seemed clunky and would require a lot of destructuring that i wouldn't be the biggest fan of writing (also, yes, this is basically a Cow, but i felt this would be better for visualization)

maybe a wrapper struct around a StringWrapper enum, i thought? that way we can impl Display and such to make it a bit easier on us? no, then we'd still have to do a lot of weird destructuring and such whenever we wanted to try to edit the data in it, and that meant that we could still have an invalid state (have a StaticStr where we expected a String, etc), and we don't want that (also still a problem with a Cow)

what about just making it store a reference? e.g.

struct Person<'f> { name: &'f str, age: usize, // sky's the limit attributes: &'f [&'f str] }

this way, we could create it at compile-time, and it would be a Person<'static>, so it could live forever (as we want). Then we could also create it at runtime. but the caveat is that I want to OWN the data in it - nothing else will be holding onto that name or those attributes, so we can't hold them as references to something else.

the solution (that i just learned about, which is why i'm sharing this): the 'static bound! don't we already have that, you may say? not exactly - here's what I'm talking about

struct Person< S: 'static + AsRef<str>, A: 'static + AsRef<[S]>, > { name: S, age: usize, attributes: A }

this way, we can have both a Person<String, Vec<String>> and Person<&'static str, &'static [&'static str]>, which fulfills all our use cases! the 'static bound binds the parameter itself, as opposed to the 'f bound earlier, which only bound the lifetime of the references (preventing owned data).

and, with the AsRef bounds, we can do something like the following:

impl<S, A> ToOwned for Person<S, A> where S: 'static + AsRef<str>, A: 'static + AsRef<[S]> { fn to_owned(&self) -> Person<String, Vec<String>> { Person { name: self.name.as_ref().to_owned(), age: self.age, attributes: self.attributes.iter() .map(|a| a.as_ref().to_owned()) .collect() } } }

(some of that syntax may be slightly off, but whatever, you get the point) - this'll allow us to easily convert any Person instance to a Person which we can modify easily (since a Person<&'static str, &'static [&'static str]> was probably created at compile-time and is thus immutable)

now, to be fair, we could just remove the 'static bounds and make a struct like the following:

struct Person<S: AsRef<str>, A: AsRef<[S]>> { ... }

and it would work everywhere our old struct (with the 'static bounds) would, and more! isn't that cool?

no! at least, i don't think so. making it impossible to construct invalid states is very important imo, and (in my use of this struct, at least), it would be an invalid state to instantiate this struct with non-'static lifetimes (e.g. where those parameters reference something else). maybe that'll change in the future as the uses of this struct change, but maybe not.

also check out Code and Bitters' article on the same topic, which talks about similar stuff but more in the context of thread spawning and how they ensure lifetime bounds are valid

[andreapasson]

DESTRUCTURED

© Andrea Passon / www.andreapasson.it

[artdenoe]

Destructure

By Art de Noé

[i-love-you-very-much]

you can't call it a 4 cheese sauce if the only cheese you put in is ricotta. also destructuring ricotta in barely salted water is not a sauce, it's a mess. there's not even anything else in the calzone

[noushkanel]

Veste en patchwork de chutes de tissu

90% des tissus proviennent de @piecesmonteesasso

Partir de formes simples, rectangulaires, sur le modèle du kimono ou de la "bog jacket" pour créer une veste zéro déchets (ou presque), puis froncer, pour destructurer la géométrie.

Taille XL

[apexulansis]

V: THE ELDER SCROLLS

The Khajiit mind is not engineered for self-reflection. We simply do what we do, and let the world be damned. To put into words and rationalize our philosophy is foreign, and I cannot guarantee that even after reading this, you will understand us. Grasp this simple truth -- "q'zi no vano thzina ualizz" -- "When I contradict myself, I am telling the truth."

While the Yukari Clan is scarcely known outside of Elsweyr, and almost not at all outside of southern Tamriel, any Khajiit who knows anything about the vampires of their land know of the Yukari. The first official recordings of the existence of this shadowy clan is a description of their long-reigning matriarch, of whom matches several vague descriptions in documentations that predate even the First Era.

They spoke of a cat of the night, one made of contraditions who slunk effortlessly in shadows despite fur as white as foreign snow. Eyes touched by Sheggorath, and fangs touched by Sangiin, ivory stained crimson. There were tales of the way she devoured others long before she had a name, before she was even recognized for what she was — a vampire. The strain of vampirism was foreign as she was to her own home-land, named Noctiremia Sangiivoria. It's thought that the first matriarch of Clan Yukari is the very same throughout each era, but any information regarding the clan's specific strain of vampirism is inconsistent and frequently changing. Some claim to have been told by the matriarch themselves, but they are thought as liars, as precious few meet the matriarch and live. Some say Sangiin for obvious reasons, but others have insisted Mefala, Sheggorath, Hemorah, Hircine… And with each claim is a story to warrant the suspicion.

The clan is small and scarcely seen. Other than the matriarch, only two others have ever been spotted.

Yeskiv is known as Yazh'ves-ri Yukari; she's an ancient Khajiiti vampire, but not only a vampire — a lich as well. The rumors of her consuming blood, body, and soul alike are all equally accurate as each other. She devours life to sustain and empower herself, and as such is an incredibly powerful necromancer. She's talented at all schools of magic, given she's multiple eras old, but is most proficient in destruction, alteration, and conjuration.

Much of her motivation towards lichhood was for the simple fact that having her blood-born children, her twins, tear her body apart. The scholars — many of which are other necromancers in northern Elsweyr — tell this story and say that the reason for this is because her children were demi-gods, born of her flesh and the daedra, and as such would have a tumultuous birth befitting their inherently destructure natures, and that lichhood was the only way for Yazh'ves-ri to ultimately survive this… But nothing has ever been confirmed, and it is only rumor.

A'dar-ka and Zar'va-ra are her twin children, two cathay-raht, albino and vampiric like their mother. Them being born vampires begs the question as to their immortality, as vampires are often known to be frozen at the age they were first turned… But once again, nothing more regarding this has been documented, and anything said is heresay. It isn't even known if the twins were truly born turned or if their mother, at some point in their adulthood, performed a ritual then.

A'dar-ka, some time in the third era, escaped his clan that had once thought to be gone, and has been wandering Tamriel since, avoiding their sibling in the process who intends to track him down and take him home. He goes instead by Black-Talons (or, since many can't be bothered for the extra syllable, just Talon), an imposing Khajiiti bounty-hunter known most of all by the prolific face of his silver mask. Consequently, Zar'va-ra is frequently mistaken for their twin after coming upon a place he'd already been, as they share the same physique and the same mask, crafted in the very same forge.

[net-craft]

12 Top Kotlin Features to Enhance Android App Development Process

Kotlin is a modern and concise programming language that is designed to run on the Java Virtual Machine (JVM). Kotlin is officially supported by Google as a first-class language for Android app development since 2017. Kotlin has many features that make it a great choice for Android app development, such as interoperability with Java, null safety, coroutines, extension functions, data classes, and more. In this article, we will explore 12 top Kotlin features that can enhance your Android app development process and make your code more readable, maintainable, and efficient.

1. Interoperability with Java: Kotlin is fully interoperable with Java, which means you can use existing Java libraries, frameworks, and tools in your Kotlin code without any hassle. You can also mix Kotlin and Java code in the same project and call Kotlin code from Java and vice versa. This makes it easy to migrate your existing Java code to Kotlin gradually or use Kotlin for new features in your existing Java project.

2. Null Safety: Kotlin has a built-in null safety feature that prevents null pointer exceptions, which are one of the most common causes of crashes in Android apps. Kotlin distinguishes between nullable and non-null types and enforces you to check for null values before using them. You can also use the safe call operator (?.) or the Elvis operator (?:) to handle null values gracefully.

3. Coroutines: Coroutines are a way of writing asynchronous and non-blocking code in Kotlin. Coroutines allow you to perform multiple tasks concurrently without blocking the main thread, which improves the responsiveness and performance of your app. You can use coroutines to handle network requests, database operations, background tasks, etc. Coroutines are also easy to write and read, as they use a sequential and suspending style of coding.

4. Extension Functions: Extension functions are a way of adding new functionality to existing classes without modifying them or creating subclasses. You can define extension functions for any class, even if you don’t have access to its source code. Extension functions are useful for adding utility methods or customizing the behavior of existing classes.

5. Data Classes: Data classes are a way of creating classes that mainly hold data and provide some basic functionality, such as getters, setters, equals, hashCode, toString, etc. You can create data classes by adding the keyword data before the class declaration. Data classes are useful for representing model objects or data transfer objects in your app.

6. Destructuring Declarations: Destructuring declarations are a way of unpacking multiple values from a single object or collection into separate variables. You can use destructuring declarations to simplify your code and make it more readable. For example, you can use destructuring declarations to assign the properties of a data class or the elements of a list or a pair to separate variables.

Continue reading 12 Top Kotlin Features to Enhance Android App Development Process