#convert string to array

[trickinabucket]

Coding is funny as fuck (while ur not doing it.) i was trying to get something to work and it had been like an hour+ before i tried something else, longhand. (But simple way, so I still kiiinda saved some time?)

Ed was in the room w me and hearing me bitch and cuss and plead to the fucking computer, occasionally injecting jokes in my miserable fit.

I figured out what it was, faced ed, sneered and put my head in my hands. Told them, “I figured out the answer.”

Ed waited for me to continue, because what the fuck does that mean when u dont code.

Then, I said: “I don’t like the answer.”

[crescentmp3]

implementing atoi by hand is a nightmare.

[infoanalysishub]

PHP Casting Tutorial with Examples – Type Conversion in PHP

Learn PHP type casting with real examples. Understand how to convert data types using (int), (float), (string), (bool), and more in PHP. PHP Casting: Complete Guide with Examples Type casting is an essential concept in PHP that allows you to convert a variable from one data type to another. PHP is a loosely typed language, which means it does automatic type conversion based on the context.…

[relto]

gotta love that all the php docs you can find tell you that calling oci_new_descriptor will let you create an empty lob object, which keeps failing, and then i find a random bug report from 2006 about this exact thing not working and it turns out this function does in fact NOT create a valid lob object.

[yippee-ki-yoyo]

.

[girlballs]

oh cool you can like. access a specific character within a string in godot by treating it like an array. which makes converting to arbitrary numerical bases pretty easy. like e.g. decimal to hex and binary here. not sure if there's a practical use for this though

[exitwound]

hi yeah sorry. what the actual fuck is that code. your variable naming conventions hurt me. thanks for using snakecase though that justifies it

its just a homework assignment im not ever gonna need to remember whats happening in it in the future or collaborate on it with others so im not worried also it makes sense to me rosewater is the original array because it looks like rose petals. the indexed arrays when converted to a list are given a second descriptor relating to the idea of a kind of residue or decomposition that might be relevant to the first descriptor, and then i picked words related to the combination of or relationship between the first and second descriptors for the last set of variables to contain the lists joined up into strings, to represent the joining up of components

[byteofsoup]

pointing up emoji nerd emoji ermm C++ forbids converting a string literal to char*. Ok who asked? Can you tell me who asked? I'm the programmer here. You're converting that string literal into an array of chars whether you like it or not

[itsjunetime]

tier list of rust std modules let's go

Rationale below the break

S

clone: It’s so important. You gotta be able to clone data around, and you gotta be able to restrict that ability. Crucial

collections: I use this every-fucking-where. Gotta have my HashSet, gotta have by BTreeMap. You know it

future: Love writing futures, love constraining futures, love all of that. And I gotta have that Future trait.

iter: Literally #1 - fucking love my iterations, wish I could write literally everything as an Iterator

option: Option is so fundamental. So many helper methods on it as well, beautiful functionality

ptr: If you’ve ever written complex ffi bindings or collections replacements, you know what I mean. The documentation is phenomenal and only getting better, the provenance projects are making it even even better.

result: Same rationale as option

sync: Arc my beloved. Also channels, mutexes, RwLocks, Atomics, etc, are all so important. Can’t do anything in multi-threaded code without using at least one of them.

vec: We all love Vec. I don’t think I need to explain myself.

A

alloc: Pretty cool and good, would love to see the allocator API stablized and then this would easily be an S tier

array: Manipulating arrays is very nice and good and useful, I just don’t don’t do it enough to put this in S

boxed: Love Box! Really nice and useful. Not something you’ll use in your every-day rust app, though, you only start using it once you’re really getting into the weeds or interacting with futures outside of async/await

cell: Very important to a lot of underlying abstractions in Rust, but just not something most people will really ever use (at least in my experience)

cmp: Useful utilities. Love the way they’re integrated with the langauge operators. V cool.

convert: Also useful! Love my (Try)?(From|Into)

default: Useful sometimes, but I feel like it’s abused occasionally. Also not a fan of seeing Default::default() where someone could’ve used the type name

fs: Gotta interact with a filesystem. Just feel like most rust apps spend most of their time not interacting with a filesystem.

marker: Very important, but most people won’t be interacting with these again.

mem: Love these, very useful, but mostly only useful for specific scenarios.

ops: Hugely important as well, obviously, but most people won’t ever actually manually access this module.

slice: Love manipulating slices - getting chunks, windows

B

borrow: Love Cow, but the whole Borrow vs AsRef thing still confuses me. I understand how they’re different, but I don’t quite understand the historical and tehcnical reasons for it, and feel like there could’ve been a better solution found to avoid this.

arch: Cool and such, but rarely used and a lot of the coolest stuff (portable simd) is still experimental and I rely on it a lot for performance reasons and really want it to stabilize soon.

error: std::error::Error. Woohoo

fmt: Nifty and such. It’s just kinda boring in comparison to all the other cool language features that exist in the standard library.

io: Cool, I guess. I just rarely every use it directly, I guess. And I am also kinda annoyed that AsyncRead and AsyncWrite aren’t things but also I think that the Async variants of traits could be avoided if people wrote more libraries in the sans-io style, so idk

panic: Mmm. I’m glad that the language provides a way for you to clean up during a panic, but I am personally really annoyed that panics are, in the end, recoverable. Irks me.

path: Path and PathBuf woohoo. Also tho such a pity that this module has to be a lot more complex due to windows backwards path separator bullshit. ugh

rc: Rc. Woohoo. I don’t like Rc much personally, I’ve written a lot of code in Rust and I’ve yet to encounter a scenario where I think “This situation could be solved or even helped by an Rc!”. But I understand its uses I guess.

str and String: Useful, yeah, but I’ll always be a bit pissed that they didn’t call them String and StringBuf instead (like they did with Path and PathBuf). Causes way too much confusion to early-on rust users

task: Useful, but I don’t get why they aren’t in future instead. Like, I guess they are used for streams and such, but still.

time: Fine… I guess it’s useful for people to be able to measure elapsed durations for logging and such and easy benchmarking but I just have a natural, deep-seated fear of any computer code that tries to interact with time as a concept so I’m very leery of this.

C

any: Mmmmmm I know it’s useful but I kinda hate that dyn Any is a thing you can do. It should (hopefully) become somewhat less prevalent now that trait upcasting is stabilized, though.

env: Used to be higher, but the whole ‘Linux makes no guarantees about accessing the environment from multiple threads’ thing irks me. I know it’s not Rust’s fault, but I’m still punishing them for it.

ffi: Confuses me that there’s so much duplication between this and os::raw - don’t like it. I know it doesn’t really matter which one you use, but whatever.

hash: Rarely actually interact with it directly. I know that it has to exist to facilitate (Hash|BTree)(Map|Set) but I don’t know what other use it has

net: Nearly all the time that I want to interact with stuff like TcpStream, I would rather use some async-specific net structs, such as are found in tokio.

num: Useful and cool, but I really think that this is seriously missing the traits from the num crate. There’s probably some specific reason why they don’t want to provide this, but the ability to reason around numeric attributes would be so useful.

os: OsStr and OsString suffer from the same sin as str vs String, but also are just inherently confusing due to the complexity that surrounds file paths in different OSes. I know that rust just surfaces all this complexity that hides beneath the surface but that doesn’t keep me from feeling like there was probably some better way to set up these structs

process: std::process::exit. woohoo

thread: Rarely do I spawn a thread manually - generally I want to use tokio or rayon or crossbeam or something like that. Good and useful, just rarely reached to and generally you’d be better off touching something else

D

backtrace: Good for one thing alone, which can be nice for quick and easy debugging, but if you just want a backtrace, a panic!() is easier, and if you can’t do that for whatever reason, you should probably just reach for a full debugger at that point

hint: Just like compiler fuckery. Love it, I do, but rarely do people interact with it, if ever, and really only useful for benchmarks and low-level atomic stuff (which, when I’ve done that, idk if I’ve even seen any sort of performance gains from spin_loop() sooo)

pin: Yes it’s important, but the constant struggle to make it not horrible to use for library developers really irks me. Still no way to (safely) match on pinned enums, no built-in pin projection without macros, etc. Ugh.

prelude: Yeah sure, whatever. You’ll never touch this.

primitive: This does need to exist, but if you’re reaching for this, you’ve fucked up. What are you doing.

F

ascii: I feel like this was a mistake. There are 4 things in it and 2 of them are deprecated. What are we doing.

char: Too many weird things here. Why does to_lowercase return an iterator? Why are these constants not in the primitive type instead? The whole escape stuff also feels arbitrary, and that’s part of the sin of the ascii mod.

f32 and f64: Everything here should be relegated to the primitive types. No need for these. Why are the integer types deprecated while this one isn’t? idk

(I also posted basically this exact same thing on my blog, june.cat, if that sort of thing interests you :))

[zandyland]

Say, for the sake of argument, you want to make a bad programming language. Why would you do this?

Well, for instance, you might get your hands on a book of scripts to generate ephemera for celestial events, only to find out it was written for Microsoft QuickBasic for Macintosh System 7. You quickly discover that this particular flavor of BASIC has no modern interpreter, and the best you can do is an emulator for System 7 where you have to mount 8 virtual floppy disks into your virtual system.

You could simply port all the scripts to another BASIC, but at that point you might as well just port them to another langauge entirely, a modern language.

Except QuickBasic had some funky data types. And the scripts assume a 16-bit integer, taking advantage of the foibles of bitfutzery before converting numbers into decimal format. BASIC is very particular -- as many old languages are -- about whitespace.

In addition to all this, BASIC programs are not structured as modern programs. It's structured to be written in ed, one line at a time, typing in a numbered index followed by the command. There are no scopes. There are no lifetimes. It's just a loose collection of lines that are hopefully in a logical order.

So sure, I could port all these programs. But I'm sure to make mistakes.

Wouldn't it just be easier, some basal part of my brain says, to write your own language that some some modern ameneties, that you compile for your own laptop, that kind of acts like BASIC? A language where you just have to translate particular grammar, and not the whole structure of the program?

Of course it's not easier. But I'm already too far in to quit now.

Memory

Who doesn't love manual memory layout?

In QuickBasic, memory is "kind of" manual. The DEFINT and DEFDBL keywords let you magically instantiate types based on their first letter. I don't know how you deallocate things, because all the scripts in this book finish quickly and don't hang around to leak a lot.

In QuickBasic, this looks like

I guess that the second statement just overrides the first.

There is no stack in a BASIC program, so there will be no stack in my language. Instead you just give names to locations.

creates a symbol named age and makes it refer to 0x1F. The pointer operator should be obvious, and the walrus means we're defining a symbol (to be replaced like a macro), not doing a value assignment during the execution of the program. Now we can assign a value.

Atoms infer types. age knows it's an int.

You cannot assign a new type to an atom.

However, you can cast between types by creating two atoms at the same address, typed differently.

The language does not convert these, it simply interprets the bits as the type demands.

Larger types

Not all types are a single word. Therefore, you can use the range operator .. to refer to a range of addresses.

Note that strings are stored with an extra byte for its length, instead of null-terminating it. Assignment of a string that is too long will result in a compilation error.

Next and Auto

There are also two keywords to make the layout of memory easier. The first is :next which will place the span in the next available contiguous location that is large enough to hold the size required. The second is :auto. For all :auto instances, the compiler will collect all these and attempt to place them in an intelligent free location. :auto prefers to align large structs with 64-word blocks, and fills in smaller blocks near other variables that are used in the same code blocks.

String Allocation

Strings come with a macro to help automatically build out the space required:

This is equivalent to:

That is, a string with capacity 5, a current size of 0, and zeroes (null char) in all spots. This helps avoid memory reuse attacks. ZBASIC is not a secure language, but this is still good practice.

There is also another macro that is similar to a "string literal".

Verbose and annoying! Just like BASIC.

Array Allocation

Likewise, arrays have a similar macro:

Which expands in a similar way as strings, with a capacity word and size word. The difference here is that the type given may change the actual size of the allocation. Giving a type that is larger than a single word will result in a larger array. For instance, f64 takes up two words some systems, so array::empty!(5, f64) will allocate 10 words in that case (5 * 2). Larger structs will likewise take up even more space. Again, all this memory will be zeroed out.

Allocation order

As an overview, this is the order that memory is assigned during compilation:

Manual Locations -> Next -> Auto

Manual locations are disqualified from eligibility for the Next and Auto phases, so a manual location will never accidentally reference any data allocated through :next or :auto.

Here is an example:

This produces the initial layout:

Which, after the code is run, results in the memory values:

Note that types are not preserved at runtime. They are displayed in the table as they are for convenience. When you use commands like "print" that operate differently on different types, they will be replaced with one of several instructions that interpret that memory as the type it was at compile-time.

Truly awful, isn't it?

[kafus]

well that was a fun exercise.

i have this old function made for reading multiple bytes in an array as one big number, and not only is it a total mess, but it requires bytes to be passed in as strings in a 0x00 format, which is just... really weird, don't ask me how i landed on this months and months ago

well now i have this instead

instead of messing with converting strings and stuff, everything is numbers from the start, lol. and it can handle little endian if i want! the thing i'm actually using this for is big endian 99% of the time but still, why not. i feel like i learned a good bit doing that. that was fun

whee!

[nectoy7]

Understanding Java Data Types: A Comprehensive Guide

Java, one of the most widely used programming languages, is known for its portability, security, and rich set of features. At the core of Java programming are data types, which define the nature of data that can be stored and manipulated within a program. Understanding data types is crucial for effective programming, as they determine how data is stored, how much memory it occupies, and the operations that can be performed on that data.

What are Data Types?

In programming, data types specify the type of data that a variable can hold. They provide a way to classify data into different categories based on their characteristics and operations. Java categorizes data types into two main groups:

1. Primitive Data Types

2. Reference Data Types

Why Use Data Types?

1. Memory Management: Different data types require different amounts of memory. By choosing the appropriate data type, you can optimize memory usage, which is particularly important in resource-constrained environments.

2. Type Safety: Using data types helps catch errors at compile time, reducing runtime errors. Java is a statically typed language, meaning that type checks are performed during compilation.

3. Code Clarity: Specifying data types makes the code more readable and understandable. It allows other developers (or your future self) to quickly grasp the intended use of variables.

4. Performance Optimization: Certain data types can enhance performance, especially when dealing with large datasets or intensive calculations. For example, using int instead of long can speed up operations when the range of int is sufficient.

5. Defining Operations: Different data types support different operations. For example, you cannot perform mathematical operations on a String data type without converting it to a numeric type.

When and Where to Use Data Types?

1. Choosing Primitive Data Types:

Use int when you need a whole number without a decimal, such as counting items.

Use double for fractional numbers where precision is essential, like financial calculations.

Use char when you need to store a single character, such as a letter or symbol.

Use boolean when you need to represent true/false conditions, like in conditional statements.

2. Choosing Reference Data Types:

Use String for any textual data, such as names, messages, or file paths.

Use Arrays when you need to store multiple values of the same type, such as a list of scores or names.

Use Custom Classes to represent complex data structures that include multiple properties and behaviors. For example, a Car class can encapsulate attributes like model, year, and methods for actions like starting or stopping the car.

1. Primitive Data Types

Primitive data types are the most basic data types built into the Java language. They serve as the building blocks for data manipulation in Java. There are eight primitive data types:

Examples of Primitive Data Types

1. Byte Example

byte age = 25; System.out.println(“Age: ” + age);

2. Short Example

short temperature = -5; System.out.println(“Temperature: ” + temperature);

3. Int Example

int population = 1000000; System.out.println(“Population: ” + population);

4. Long Example

long distanceToMoon = 384400000L; // in meters System.out.println(“Distance to Moon: ” + distanceToMoon);

5. Float Example

float pi = 3.14f; System.out.println(“Value of Pi: ” + pi);

6. Double Example

double gravitationalConstant = 9.81; // m/s^2 System.out.println(“Gravitational Constant: ” + gravitationalConstant);

7. Char Example

char initial = ‘J’; System.out.println(“Initial: ” + initial);

8. Boolean Example

boolean isJavaFun = true; System.out.println(“Is Java Fun? ” + isJavaFun);

2. Reference Data Types

Reference data types, unlike primitive data types, refer to objects and are created using classes. Reference data types are not defined by a fixed size; they can store complex data structures such as arrays, strings, and user-defined classes. The most common reference data types include:

Strings: A sequence of characters.

Arrays: A collection of similar data types.

Classes: User-defined data types.

Examples of Reference Data Types

1. String Example

String greeting = “Hello, World!”; System.out.println(greeting);

2. Array Example

int[] numbers = {1, 2, 3, 4, 5}; System.out.println(“First Number: ” + numbers[0]);

3. Class Example

class Car {     String model;     int year;

    Car(String m, int y) {         model = m;         year = y;     } }

public class Main {     public static void main(String[] args) {         Car car1 = new Car(“Toyota”, 2020);         System.out.println(“Car Model: ” + car1.model + “, Year: ” + car1.year);     } }

Type Conversion

In Java, type conversion refers to converting a variable from one data type to another. This can happen in two ways:

1. Widening Conversion: Automatically converting a smaller data type to a larger data type (e.g., int to long). This is done implicitly by the Java compiler.

int num = 100; long longNum = num; // Widening conversion

2. Narrowing Conversion: Manually converting a larger data type to a smaller data type (e.g., double to int). This requires explicit casting.

double decimalNum = 9.99; int intNum = (int) decimalNum; // Narrowing conversion

Conclusion

Understanding data types in Java is fundamental for effective programming. It not only helps in managing memory but also enables programmers to manipulate data efficiently. Java’s robust type system, consisting of both primitive and reference data types, provides flexibility and efficiency in application development. By carefully selecting data types, developers can optimize performance, ensure type safety, and maintain code clarity.

By mastering data types, you’ll greatly enhance your ability to write efficient, reliable, and maintainable Java programs, setting a strong foundation for your journey as a Java developer.

[mexsel]

Understanding Solar Panel Inverters: Types and Functions

The solar power industry has grown tremendously over the past few decades and is expected to continue growing at over 6% CAGR by 2032. This growth has significantly impacted the solar panel inverter market, which is projected to grow at a 7.7% CAGR over the same period. As a result, solar power stocks have seen a substantial increase. In this article, we'll explore the types and functions of solar panel inverters, a crucial component of any solar power system.

What is a Solar Panel Inverter?

Solar panels consist of silicon photovoltaic (PV) cells that convert sunlight into electrical energy. However, the electricity produced by solar panels is in the form of direct current (DC), which is not suitable for home appliances. Home appliances require alternating current (AC), where the flow of electricity reverses periodically. This is where solar panel inverters come in—they convert DC electricity into AC electricity.

To clarify, DC electricity flows in a single direction, making it efficient for transferring power over short distances without significant losses. However, for practical home use, AC electricity is necessary due to its ability to travel over longer distances with less energy loss. The solar panel inverter acts as an intermediary, converting DC from the solar panels to AC for use in the home or office. Additionally, in an on-grid solar system, the inverter connects the solar panels to the local electricity grid, allowing for net metering and storing excess energy in batteries.

Why is an Inverter Necessary in Solar Power Systems? Solar panel inverters perform several essential functions that make them crucial for any solar power setup:

Converting DC to AC: The primary function of a solar inverter is to convert the DC electricity produced by solar panels into AC electricity, making it usable for home appliances.

Monitoring Solar Panel Performance: Most solar inverters come with built-in monitoring capabilities, allowing you to track the amount of electricity being converted and identify any issues with the solar panels. This feature helps ensure optimal performance and identify potential problems early.

Connecting to the Grid: Inverters connect your solar system to the local utility grid, enabling you to sell excess electricity back to the grid for a credit or financial return. This connection also allows you to draw electricity from the grid when your solar panels aren't producing enough power, ensuring a reliable power supply.

Optimizing Solar Panel Efficiency: Some inverters, such as power optimizers, help maximize the efficiency of each solar panel. Factors like shading, orientation, and debris can cause individual panels to produce different amounts of electricity. Power optimizers adjust the output of each panel to ensure a consistent flow of electricity from the entire array.

Protecting Your Electrical System: Solar inverters also play a protective role by preventing electrical overloads and short circuits. They have built-in safety features that shut down the system in case of overvoltage or other electrical issues, protecting your home and solar investment.

Types of Solar Panel Inverters

There are three main types of solar panel inverters commonly used in residential systems:

String Inverters: This is the most traditional type of solar inverter, similar to a centralized air conditioning system. All solar panels are connected in series to a single inverter. String inverters are most effective in situations where all panels receive equal sunlight without shading. However, if one panel is shaded or malfunctioning, it can reduce the output of the entire system.

Microinverters: Microinverters are installed on each individual solar panel, allowing for more precise energy conversion and monitoring. This setup is ideal for installations where panels face different directions or are prone to shading.

Power Optimizers: Power optimizers combine the benefits of string inverters and microinverters. Each panel is equipped with an optimizer, which adjusts the output to match other panels before sending the DC electricity to a centralized inverter for conversion to AC.

Conclusion Solar panel inverters are essential for converting the DC electricity generated by solar panels into AC electricity suitable for household use. They also play a vital role in monitoring system performance, optimizing efficiency, connecting to the grid, and protecting your electrical system. Choosing the right type of inverter—string inverter, microinverter, or power optimizer—depends on your specific needs, including your budget, site conditions, and energy goals.

[eventtitans]

The Anatomy of a Perfect Event Page: Boost Your Attendance with Tickets99

The deal occurs when your Event Page grabs eyeballs and pushes them into buying the tickets; the rest is just half the work done in creating the event. This is where a great Event Page holds the difference to your getting live audiences or going home empty. At Tickets99, we master the art of making compelling event pages to pull in, engage, and convert site visitors into attendees.

In this article, we are going to perform surgery on the anatomy of an ideal event page and identify the key elements that can get your event to turn into success. The best part is we'll showcase a firm brimming with features: Event management software firm platform, which is going to help you to design an event website doing all this and a lot more.

Inviting Title and Description of Event

Title:

The event title is the first bit visitors will see, so make it savvy, informative, and attention-getting. It should give your visitor an instant feel for what your event is all about.

Example: "Summer Beats Festival: Get Ready for a Night to Remember with Great Music and Loads of Fun"

Description:

Give a brief, attractive description noting the event type, major attractions, date, time, and location.

Sample: "Come and join the Summer Beats Festival, a night full of electrifying performances from the finest DJs, gourmet food trucks, thrilling activities, and fun. Cannot wait to welcome August 20th, 6 PM to midnight, Central Park."

2. High-Resolution Visuals

Images are bound to make all eyes wander at best and puzzle together a bright, active image of your event. Apply our favorite high-resolution photographs and playful video clips to pique their interest in what they're here for.

How to implement:

Upload pictures of past events.

Upload any videos that may offer the user 'behind-the-scenes' of the performances/ activity/speaker.

3. Comprehensive Event Schedule

An event agenda will enable your attendees to plan their day. It also creates suspense for each particular session, performer, or activity tied up to the day. For instance:

6:00 PM: Gates Open

6:30 pm – 7:30 pm: Opening Act : The Local Band

8:00 PM - 10:00 PM: Headline Performance - DJ Awesome

10:30 PM -12:00 Midnight: After Party with Special Guest

4. Speaker and Performer Information

Feature each of the other key speakers or performers at your event. Included would be their bio, image and social media or website link.

Example:

DJ Awesome: A world-class DJ that has lit up global stages with his high-octane shows and that boasts a string of top-rated hits on music charts.

5. Showcase Sponsors and partners

Adding sponsors and partners will help build reliability and support to your event. If they showcase it on the event page, it might add some great relations with potential sponsors for the future events you would host.

Example:

Sponsored by:

XYZ Beverages

ABC Clothing

123 Tech Solutions

6. Social Media Integration

Add links to social media handles to drive more engagement and reach. Also, enable sharing buttons so that the attendees can share your event with its network/profile, quite easily.

Best Practices:

Show live feeds of social media.

Create a buzz by using event-specific hashtags.

7. Event-Specific Website

When you have such an array of elements on one page for any event, it could get overwhelming, except that it is pretty easy to do when using Tickets99. It gives you a totally end-to-end event website that eases registration, manages digital campaigns, and tracks engagements of attendees in real-time.

Key Features:

Multimedia Showcase: Display high-quality images and videos to entice them on what is coming their way.

Social Handles Integration: Add and display your social media handles for increased user interaction.

Past Events and Speaker Details: Show past event accomplishments and a big brief for a speaker/performer.

Sponsor Highlights: Bring sponsors up on stage for maximum credibility and to have a good relationship with them.

Upcoming Agenda Display: Includes a detailed session itinerary to allow your user to view a glimpse of the event in advance.

With Tickets99, registering for an event really couldn't be easier. Now you can prepare custom agendas for your event, conduct digital campaigns E2E for your event, and monitor the real-time engagement of the attendees in the events being managed within your organization. All the event's information is in one place and readily available at the attendees' fingertips, reducing the hurdles to keep abreast of it all and remaining in a rush.

8. CTA Clearing

Your landing page, as with everything else, should have only one clear and compelling call to action. Again, in this way, it's very easy for that site visitor to go ahead and buy tickets or register, so put a clear and visually appealing CTA right on the page.

Eg.

Get Your Tickets Now!

Register Today and Save!

Conclusion

Preaching appointments and event pages is one model toward making your event a success. This does not only preach attendance but incorporates the features aforementioned and uses the great features set out on Tickets99; you get an event page that not only attracts but also engages and finally converts visitors into attendees.

Ready to elevate your next event? Click on through to Tickets99 today to get started building out your perfect event page.

[reversedumbrella]

your colour seperating program, I made something basically identical a few years ago in Python, would love to hear an in depth everything about it, especially how you made the spinning gif

Sorry for the delay I've been kinda busy. I also had various reasons I didn't want to share my code, but I've thought about a better/different way so here it goes (but for the time being I'm as far away from my computer as I possibly could)

I used processing, which is, as far as I remember, based on java but focused on visual media

Starting with the gif part, processing has the save() and saveFrame() methods that save the image displayed, and it also has the "movie maker" that allows you to make GIFs (and others but I don't remember)

I don't know about other languages but processing runs setup() when it starts and draw() every frame

In setup() I load an image as a PImage (processing's image data type like an array or string) and access it's pixel list. Using that I fill a 256x256x256 int array where every color corresponds to a place in the array. This 3d int array is filled with the amount of times each color appears

Lastly I use a log function to convert those numbers into the dot size

During draw() I run through this array and use the point() method to draw every dot (I can define a dot's color using stroke() and it's size using stroke weight() )

There are some optimisations I don't have the patience to explain at the moment

Processing has various render modes. I've made 3d images using the 2d render but I didn't want to repeat the feat (pov: you make 3d in 2d and then your teacher explains the existence of 3d to you). It also has the translate() that moves the origin and rotate(), rotateX() rotateY() and rotateZ() that allows you to rotate the image

I don't know how much you know about processing so sorry if you don't understand or if I'm explaining things you already know

[autisticrustacean]

Why, What, and How; tuples in rust

When I first learned rust tuples were a tad funky, they were like arrays, but not index-able at runtime, I had never really touched something like that before (to my understanding), so I figure I should share my way to get my head around them.

Why

tuples serve simple role, compound multiple types into one, which is great for returning multiple values, if I want to return a string, and some sort of flag to say what that string could be representing, I can just return (String, T), then the caller can use T to determine what to do instead of mucking around with complicated string parsing.

perhaps I need two or more values of possibly different types to represent what I'm representing, for example a simple Linked list node may want to be an optional pointer to the next node, and it's value; Like (T, Option<Box<(T, Option<Box... wait a minute this is recursive, It needs a name to be written out like this so you should use a struct not a tuple! but what's a struct?

What

something that blew my mind is the ability to know what a struct is, it's an named tuple, if you give a tuple a name, and maybe some trait impls or methods, you've made a struct, simple as.

this is why the syntax to get a field and to get a tuple element is so similar, tuples use numbers instead of names, but their the same concept.

but that doesn't actually explain what a struct or a tuple is, it's pointing to the other and saying their the same.

How

a tuple is a chunk of contiguous memory, with a known (to the compiler) layout, it's like if an array could have multiple types, it holds all it's elements together in a sequence and you can cut out all but the value you want since you know where it is already. the reason you can't index them at runtime is that array indexing is done by moving X bytes over in memory in the array to reach the next element, which only works when you know what size something is going to be and what type it is.

A fun edge case, unit, or ()

unit is a seemingly useless type, why have a compound of nothing? it's purpose is definitely a valid one, having a single value type is a great way to round off the Rust type system, it takes no space, it's the representation of nothing, but why an empty tuple instead of some special primitive? I'd bet it's cause consistency, () has all the properties you would expect an empty tuple to have, an already existent syntax meaning no new keywords or names need be learned to use it, and is straightforward representation of nothing.

Tuple Tips!

if you're tuple is made of less than 13 elements that all implement Default, the tuple does as well, it's default value is all the default values of its elements.

if your using two equal length arrays and want to pair them together, consider instead make an array of two element tuples; think [(T1, T2)] instead of ([T1], [T2]), great for iterating over pairs of statically known values.

if your struct is just some behavior over a simple enough set of values (like an Rgb type just being (u8, u8, u8)), consider implementing Into and From for those tuples so you can easily convert between them