#NullReferenceException

[nihilseq]

fun ryuki diverge things in the flowchart view

GIGANTIC AINI SPOILERS AHEAD!!!!!!!! anyway, hello to all the lovely frayers out there. some inchresting stuff i came across while looking at the visuals for ryuki diverge route.

2/11 Ryuki Diverge splits off on a purple route to the left of 2/11 Ought To Know like such:

and when viewing 2/11 Ryuki Diverge, the left half of the "picture" is out of bounds, while the right half is visible. which is a cool choice, as the "right" halves of the body are generally associated with the "past" of the story (not actually true, but we don't learn that fact until we experience the funny switcharoo)

the funky red text is kinda overall throwing a bunch of errors for us to chew on! the ones i can see are listed below, under the cut because this got really long whoops.

System.Scenario.loader

"FatalError:sc_engine part of the system has been damaged."

"The pointer is referring to something out of range." - when looking for Flowchart/Chapter_ID.cs:8075, Flowchart/Summary_ID.cs:6745, Flowchart/Chapter_ID.cs8121, Flowchart/Summary_ID.cs:6843.

"Either the scenario file does not exist or the specified location is wrong." - when looking for Scenario_loader.cs:3863, and Scenario_loader.cs:3882,

I suspect these errors are for both chapters that the background appears behind (2/11 Ryuki Diverge and 2/15 Ryuki Diverge - so each is missing a Chapter ID, Summary ID, Scenario loader.)

System.UI.loader

"Image file not found." - when looking for ChapterIcon_test6.png

System.Render.2d.ui.textsystem

"The argument is missing data or contains invalid data." - when looking for Flowchart_info_window.cs:326

FloatchartScene/UICamera (at the very bottom covered by the blue controls bar)

"Warning! The camera position coordinates are not correct. The camera is out of display range."

makes sense... we Do have to walk out of bounds to chat with tokiko and all that

multiple lines mention NirReferenceException. to my knowledge this is Not a real exception that is thrown ... maybe a NullReferenceException but Nirvana themed because, naix!

also, because it's fun, heres a few of the frames that flicker really quickly on the little picture section:

When moving to 2/15 Ryuki Diverge using the arrow at the bottom, the camera "jumps" to the next section. Interestingly, these are the frames in between moving from 2/11 RD to 2/15 RD via the arrows:

We get a nice good look at chopped in half Aiba as we go 👍

Why is this notable? It is kind of interesting, because these images don't actually follow the direction the purple line is going - it's really hard to see, but it actually goes down the very sides of your screen and all the way to the bottom. Then, connects to 2/15 from the very top of your screen.

Initially I didn't even see the purple line, so I thought it maybe wrapped around the back of the whiteboard - but nope, time just.... broke, I guess, when it comes to Ryuki Diverge. it stays like this even if you hit Switch Flowchart to see the original version.

Also, 2/15's picture now has the left side visible and the right side lost to the void! Again, probably because the "left" halves of the body are more strongly associated with the Present day side of the flowchart.

More frames that show up for 2/15 are here:

anyway I think Ryuki Diverge looks cool as hell . even though i have some Feelings about the "it was all a simulation" concept in general. i do, in fact, enjoy the visuals, as well as the implication of what giving six years worth of information would do to a guy.

[trainsg1rl]

this was one of the first songs i ever made, i made it back in july of 2020 and it's alright. it's mixed poorly and loops in the middle, i was never happy with it and i always wanted to come back to it, three years later and i finally did :3

[iceybot]

*laughs in (NullReferenceException: Object reference not set to instance of an object)*

*asexual laughter*

[fromdevcom]

What is a NullReferenceException in C#? In C#, a NullReferenceException occurs when your code tries to use an object reference that hasn't been initialized. It's a common runtime error that happens when you try to access members (like methods or properties) of an object that is null. Since null means "no object," accessing its members causes an exception because there's nothing to access. For example: string str = null; int length = str.Length; // Throws NullReferenceException In this example, str is null, so calling str.Length results in a NullReferenceException. Common Causes of NullReferenceException Uninitialized Objects: Forgetting to instantiate an object before using it. Person person; Console.WriteLine(person.Name); // Throws NullReferenceException Objects Set to Null: An object is explicitly set to null or loses its reference during execution. person = null; Console.WriteLine(person.Name); // Throws NullReferenceException Arrays or Collections with Null Values: Accessing elements in an array or list that contain null references. string[] names = new string[5]; Console.WriteLine(names[0].Length); // Throws NullReferenceException Implicitly Null Return Values: Methods or properties that return null without validation. string name = GetName(); Console.WriteLine(name.Length); // Throws NullReferenceException if GetName() returns null How to Fix NullReferenceException Check for Null Values: Always validate objects before accessing their members. if (str != null) int length = str.Length; Use the Null-Conditional Operator (?.): This operator allows you to safely access members only if the object is not null. int? length = str?.Length; Initialize Objects: Ensure that objects are initialized before they are used. Person person = new Person(); Console.WriteLine(person.Name); Default Values: Use default values when working with potentially null objects. int length = str?.Length ?? 0; Use Debugging Tools: Leverage Visual Studio's debugging tools to trace the cause of the NullReferenceException. The call stack will show you the exact line of code where the exception occurred. Best Practices to Avoid NullReferenceException Avoid nulls whenever possible: In some cases, using design patterns like the Null Object Pattern can help prevent null values. Use nullable types: When working with value types (e.g., int?), use nullable types that indicate the variable can hold a null. Enable nullable reference types: From C# 8.0, you can enable nullable reference types, which allow you to specify whether a reference type can be null or not. This can help the compiler warn you about potential null references. Conclusion A NullReferenceException in C# is a common but preventable error. By using null checks, initializing objects, and applying best practices, you can significantly reduce the occurrence of this exception in your applications.

[cyanobotcodes]

Recent Updates

Toddlers

Fixed: toddlers can no longer generate a "need meditation spot" alert even if they have a psylink or are scheduled to meditate (which they won't do)

Fixed: error on load with mods that replace the main research window

Fixed: NullReferenceException when adults try to decide whether they need to feed a non-spawned toddler

Added: HAR compatibility for 1.5 (finally)

Colored Leather and Wool

Added: compatibility for Outland mods, Biomes! Polluted Lands

Adjusted "tanned" color of human leather to avoid washing out darker skin tones as badly

Softness Control

Added: patches for Anomaly, Medieval Overhaul

Talking Isn't Everything

Added: patch for Life Lessons

Caveworld Flora Unleashed

Increased impact of gleamcap smoke exposure

Made mycelium selectable to facilitate cutting

Added global spawn rate slider

Various code-tidying and minor performance-improvement

---

It finally feels like I'm actually making progress through the vast stack of to-dos. I'm almost out of bugs to fix. Soon I'll be moving onto adding some of the planned features to Toddlers that have been on the docket for literal years.

[removeload-academy]

Mastering C# Exception Handling: Understanding Exception Types and Managing Multiple Exceptions with Examples

Effective error handling is a cornerstone of robust programming. In C#, mastering exception handling is essential for building resilient applications. This blog delves into the different C# exception types and demonstrates how to handle multiple exceptions effectively. Whether you're a beginner or an experienced developer, this guide will provide actionable insights to enhance your coding skills.

At Removeload Educational Academy, we believe in making complex concepts simple. Our e-learning tutorial portal is designed to teach programming languages with live examples, written in a way that’s easy to understand. With free resources tailored for students eager to learn, we empower individuals to grasp the fundamentals and beyond.

Understanding C# Exception Types

In C#, exceptions represent errors that occur during program execution. Common C# exception types include ArgumentException, NullReferenceException, InvalidOperationException, and IOException. Each type serves a unique purpose, helping developers identify and fix specific issues.

For instance, an ArgumentException arises when an invalid argument is passed to a method, while a NullReferenceException occurs when attempting to access a null object. Understanding these exception types ensures that you can write code that anticipates and addresses potential issues effectively. At Removeload Educational Academy, we provide in-depth resources to simplify these concepts, ensuring that even complex topics like C# exception types removeload are accessible to learners.

Handling Multiple Exceptions in C#

In real-world applications, multiple exceptions can occur simultaneously. Handling these exceptions properly is vital to maintaining application stability. C# provides a try-catch block for error handling, allowing developers to catch and respond to exceptions gracefully.

Here is a C# handling multiple exceptions example:try { // Code that might throw exceptions int result = int.Parse("abc"); // Throws FormatException string text = null; int length = text.Length; // Throws NullReferenceException } catch (FormatException ex) { Console.WriteLine($"Format Exception: {ex.Message}"); } catch (NullReferenceException ex) { Console.WriteLine($"Null Reference Exception: {ex.Message}"); } catch (Exception ex) { Console.WriteLine($"General Exception: {ex.Message}"); }

In this example, specific exceptions are caught first, followed by a general exception handler. This approach ensures that each error is addressed appropriately without causing the program to crash.

Best Practices for Handling Multiple Exceptions

Catch Specific Exceptions First: Always handle specific exceptions before using a general catch block. This makes debugging easier and ensures proper error management.

Use Finally Blocks: A finally block executes regardless of whether an exception is thrown, making it ideal for resource cleanup tasks.

Avoid Overusing Exceptions: Only use exceptions for exceptional circumstances, not as a substitute for regular control flow.

By following these practices, you’ll master C# Handling multiple exceptions and build applications that are robust and reliable.

Why Learn with Removeload Educational Academy?

At Removeload Educational Academy, we aim to bridge the gap between theoretical knowledge and practical application. Our platform offers free online e-learning tutorials tailored for students who want to learn programming languages through live examples. Written in an easy-to-understand format, our resources make learning accessible to everyone.

Whether you're tackling complex topics like C# Exceptions removeload or starting with the basics, our tutorials are designed to empower you with the skills you need to succeed in the ever-evolving tech landscape. Join our community of learners and take the next step in your programming journey.

Conclusion

Mastering exception handling in C# is a crucial skill for any developer. By understanding exception types, handling multiple exceptions effectively, and applying best practices, you can create error-resilient applications. At Removeload Educational Academy, we’re here to support your learning journey with free, easy-to-follow tutorials. Dive into our resources today and elevate your coding skills!

[hitclub13com]

null

🏆 Khái niệm null xuất phát từ lập trình máy tính và cơ sở dữ liệu. Null là một giá trị đặc biệt được sử dụng để đại diện cho một trường không xác định hoặc không tồn tại.

Khác với giá trị zero hay chuỗi rỗng, null không phải là một giá trị cụ thể mà mang ý nghĩa là trường đó chưa được gán giá trị. Khi kiểm tra xem một trường có giá trị null hay không, ta sử dụng toán tử so sánh là null.

📚 Trong phần lớn các ngôn ngữ lập trình, null được coi là một kiểu dữ liệu đặc biệt và không phải là bất kỳ kiểu dữ liệu cụ thể nào khác. Ví dụ, trong Java, null có kiểu dữ liệu l�� Object. Còn trong C#, null có thể được gán cho bất kỳ kiểu dữ liệu nào bao gồm cả số nguyên, kiểu dữ liệu tham chiếu...

欄 Xử lý null quan trọng trong lập trình vì nó có thể dẫn đến lỗi khi truy cập phần tử mảng hoặc thuộc tính đối tượng khi chưa được khởi tạo. Do đó, cần kiểm tra xem giá trị có phải là null trước khi sử dụng, tránh gặp phải lỗi NullReferenceException hoặc NPE.

六‍💻 Nhiề

https://justpaste.it/cu1qy/pdf

[bongcloud]

Oh it was just a run-of-the-mill NullReferenceException error on Unity, I fixed it by... deleting the whole chunk and re-writing it lol :p

I reaaally tried to fix it using sources online, but i had to go full scorched-earth :( I think there was something wrong with the code that activated another two scripts? But Unity showed the error for the scripts that it activated instead of the main script? (complete guesses lol)

I dont think i can find the original error atp tho, The code that errored was from like a month ago and I am wayyy too unorganised, all interconnected scripts like a big pile of mom's spaghetti :v

You ever just be coding and get a massive red error message but like... the code just... works anyways??

[developerhelp]

What does "Object reference not set to an instance of an object" mean?

What does “Object reference not set to an instance of an object” mean?

I am receiving this error and I’m not sure what it means? Object reference not set to an instance of an object.

[sylvanas-girlkisser]

programming was a mistake

[cothers]

Direct RAM Access

All programs operate on RAM regardless of its programming language, operating system or hardware, be it a smartphone, cloud, desktop, laptop or a machine as tiny as Arduino.

Nowadays, RAM is used as a synonym for main computer memory. In reality, it is an abbreviation for "Random-Access Memory". Here, random means not as in something random; the last thing you expect from a RAM is randomness. The connection between words "random" and "access" with the hyphen means any data in memory is accessed arbitrarily by the programs.

In this context, the opposite of random is sequential, which means the memory is accessed one-by-one as we can still see in SQL result-sets. In old times, memory hardware like "tape" was sequential; to access an arbitrary location, all previous locations on the band should be visited. The access types of memory hardware may seem outdated today as tapes are obsoleted as storage devices; almost all memory are "random" for the last 20 years.

Memory types like hard disks and CD/DVDs are randomly-accessed, but one thing separates RAM from the former is the fixed access time for each location. For disks, a device called "head" should be rotated so that access times may vary depending on the location. Nowadays, hard disks are rapidly replaced by SSDs (Solid State Drive) that can store as much data as disks and provide fixed access time as RAMs.

From now on, let's assume a RAM is a sea of bytes that is addressed by a number which is represented by the data type int.

In C, you can directly access RAM via its address. Let's start with an example:

#include <stdio.h> int main(int argc, char* argv[]) { char* p = 0; printf("%c\n", *p); return 0; }

Here, we start introducing the infamous "pointers" in C. Pointers are used like "references" in modern languages, but they really are memory addresses in C.

The term "char" (character) in the variable definition is the main mental block for understanding pointers while learning C. In reality, any type of variable definition with an asterisk (*) is always an int. The preceding type specifier is used to represent data in that address later.

The variable p is assigned the address 0, or in other words, the location of the very first byte in memory to p.

char *p = 0;

Here, *p represents the data in address p as char. We'll try to write it on the standard out (stdout) with printf():

printf("%c\n", *p);

When you run this program in a PC, it crashes with the following message:

Segmentation fault (core dumped)

In Windows, it pops a message box that says "Access Violation". This fault is similar to NullPointerException, NullReferenceException etc. in modern languages.

The above program crashes because the ability to reach an address doesn't mean the memory location it refers really exists. Because modern operating systems like Linux, Windows run many programs (or processes as they are called in that context) simultaneously, they should manage precious RAM resources carefully by a mechanism called "virtual memory" that often abbreviated as VM.

Modern systems would block writing to address 0 because it almost always means a programming fault like the exceptions mentioned above. But C is also used for embedded programming, which means writing programs for very tiny CPUs which helps electronic controller hardware. Those machines have constrained hardware resources so they may not have the luxury for controlling memory access. In this instance, reading the memory at 0 or an arbitrary location may not crash.

Now let's try to assign an arbitrary address to the p:

char *p = 5500;

The compiler would give a warning for that number.

warning: initialization makes pointer from integer without a cast

This error won't halt the compilation process. But as a wise programmer, we should not accumulate warnings. Thanks to "casting", it is possible to convince the compiler that we know what we are doing with a cast:

char *p = (char *)5500;

When you run the program, the result is again the segmentation fault. As you can see, C makes it possible to shoot yourself in the foot. But you are still lucky if you shoot yourself in the foot because at least you can go to a hospital. However, if that kind of error results in reading or writing from a legal memory, then your data integrity breaks and god knows where this error pops in the future.

Playing with Valid Memory Locations

Enough of crashes. Let's use some valid memory addresses, starting with the following example program:

#include <stdio.h> int main(int argc, char* argv[]) { char c = 'A'; printf("%u\n", &c); return 0; }

Here we define a variable of 1 byte (or 1 ASCII character) as c. It represents a location in RAM which stores a byte of data. The & operator takes the address of a variable, so the output is something like this:

1868946151

Let's play a little bit more and add any variable we've encountered throughout our little program:

printf("argc %u\n", &argc); printf("argv %u\n", &argv); printf("c %u\n", &c); printf("main %u\n", main);

It outputs something like this:

argc 1527215996 argv 1527215984 c 1527216007 main 448100010

As you can see, our main function's assembly code is located somewhere in our RAM.

Now let's play with them via a pointer:

char c = 'A'; char* p = &c; printf("c %c\n", c); printf("*p %c\n", *p); *p = 'B'; printf("c %c\n", c);

Here we define a pointer p and assign it to the address of c. So p becomes a reference to the c. The output is:

c A *p A c B

Now let's do something dangerous:

char* p = main; printf("%c\n", *p); *p = 'A';

This program has the ability to read and print the first character of the main() function but crashes when trying to write into it. Modern CPUs can distinguish between code and data and prevents overwriting the code.

U Segmentation fault (core dumped)

If you try the example above, you probably get warnings but, it doesn't stop compiling anyway.

To get even more dangerous, we will use a technique called the "pointer arithmetic".

char c1 = 'A'; char c2 = 'B'; char *p = &c1; printf("C1 %u %c\n", &c1, c1); printf("C2 %u %c\n", &c2, c2); p++; *p = 'Z'; printf("C2 %u %c\n", &c2, c2);

When you run this program, the output will be:

C1 69358686 A C2 69358687 B C2 69358687 Z

As you can see, the value of c2 is changed magically by a series of manipulations.

char *p = &c1;

We first assign pointer p to the address of c1.

p++; *p = 'Z'; printf("C2 %u %c\n", &c2, c2);

Remember, a pointer is actually an int that represents a memory address. Since it is an int, it is perfectly legal to increment it. By that, we can magically change the value of c2 without mentioning it.

Control is costly. Programs written in C are very fast because allowing direct manipulation of RAM avoids that cost.

Other Languages' Perspective on Accessing RAM

Most modern languages other than C and C++ prevent direct access to RAM. Instead, they control accessing it through carefully defined interfaces called "references". First, there is no notion of taking the address of a variable for basic types like char, int, double etc.

Second, object instances are stored in a variable of reference type. The reference is an opaque type; you can't take the address of it. They are used as-is. Of course, you can change the object which the reference points to, but you can't make it pointing an invalid arbitrary address like 5500 as we have given above.

Of course, object instances do live somewhere in RAM and in the 1990s references may leak that info when you convert them into a string. Today garbage collectors (GC) may move objects around the RAM for efficiency and heap defragmentation, so that info should contain something more independent than a mere memory address.

The following Java program creates two instances of class Object and converts them into a string:

public class Xyz { public static void main(String[] args) { Object o1 = new Object(); Object o2 = new Object(); System.out.println("O1 " + o1); System.out.println("O2 " + o2); } }

The outputs are some random hash values that uniquely identify the instance that is managed by the GC. As you can see, the hexadecimal numbers are unrelated.

O1 java.lang.Object@3af49f1c O2 java.lang.Object@19469ea2

One of the main design principles of modern languages is preventing pointer errors as you can see in the preceding paragraphs. As we said before, direct RAM manipulation is what makes C programming language very fast. However, most modern software doesn't need to be fast as much. Correctness is more valued since programmers are forced to deploy programs fast in this Internet era.

Zero, Null, Nil, Undefined

References can have a special value called null or nil or undefined when they do not point to any object instance. Let's make them fail by abusing them:

String s = null; System.out.println("Length " + s.length());

The result is the Java-style "Segmentation Fault".

Exception in thread "main" java.lang.NullPointerException at Xyz.main(Xyz.java:6)

Let me stress again. In a modern programing language, the reference may be null or something real, not in-between like in C/C++.

Some more modern languages like Kotlin (a Java dialect) go even further and prevent null value assignment if you don't specifically mark the reference with a question mark:

val String s = null; // Incorrect, don't compile var String? s = null; // Correct ```` ## Leaky Abstraction Operating Systems like Linux and Windows provide C APIs for their services. A modern programming language runtime should call that APIs at some point to do meaningful things like I/O and creating windows. Each of those languages provides some means of accessing C libraries and interacting with C so you can taste the pleasure of direct memory manipulation. For example, C# programming language and its associated runtime .NET provides "Interop" library to interface with the operating system. Interop library contains a big class called Marshal, which has many dirty and dangerous static methods against all OOP principles. For example, the following methods are available to read and write a byte to/from the RAM directly:

public static byte ReadByte(IntPtr ptr); public static void WriteByte(IntPtr ptr, byte val);

IntPtr type represents a C pointer. These methods are ready to throw an "AccessViolationException" when you do the same experiments as in the above paragraphs. But when you access some valid C memory by some means outside the scope of this topic, you can use them conveniently. Read/Write methods have other variants which allow accessing different basic types like int and blocks of byte arrays at once. Now, as always, let's do some naughty things:

using System; using System.Runtime.InteropServices;

namespace savas { class Program { static void Main(string[] args) { byte b = 33; GCHandle h = GCHandle.Alloc(b, GCHandleType.Pinned); IntPtr p = h.AddrOfPinnedObject(); byte b2 = Marshal.ReadByte(p); Console.WriteLine("b2 = " + b2);

} }

} ```

After defining the variable b, we "pinned" it so the GC won't move its place in memory. Then we get its address via AddrOfPinnedObject() method just like the & operator in C, read its value and print it. The output is "b2 = 33" as expected.

But if you call Marshal.WriteByte() to manipulate p, it doesn't write into b because once you pin the object, the connection between b and p is lost. This allows C# to stay pure because the Marshal class' memory methods are designed to manipulate buffers provided by the C libraries, not the other way around.

Python programming language has been written in C. At the same time, it provides a C interface that allows built-in classes and libraries be written in C. If that kind of classes supports a "buffer protocol", its raw bytes can be manipulated by memoryview class of Python. By default, Python's standard byte and bytearray objects support that protocol.

Without memoryview, Python-way of manipulating buffers is inefficient since any operation on arrays and slices requires creating a copy of the object. Using memoryview allows C-style direct control of memory in a controlled way; "best of both worlds" in certain scenarios.

[jeremy-ken-anderson]

Fixing a bug

After a while banging my head against a bug - the dreaded NullReferenceException - I went back to best practices:

1) Think about what the bug means.

NullReferenceException means something in the program is trying to get/present info from somewhere else and the place it’s talking about straight-up has no info in it or doesn’t exist.

The most common place where this comes up in Unity is when you’re using their convenient drag-and-drop system to make references to gameObjects and you miss one of the “slots” you’ve made for yourself and leave it empty. Now your code is trying to manipulate a gameObject but nothing’s there.

Sadly, this bit didn’t solve my problem. I couldn’t find any empty slots and it really did look like the variables the system was calling bad were set up properly.

2) See whether the bug tagging was accurate.

For errors involving not having your {} lined up or not having a ; somewhere, the error messages can be wildly inaccurate about where the mistake actually happened. So I commented out the bit it was complaining about and ran the program again.

For those who don’t know coding stuff, if you type // before a line of code that bit won’t be part of the actual code the computer tries to compile. Programmers use this to leave themselves/each other comments about what bits of their code do. You can also use them to temporarily turn a line of code into a comment instead of deleting it, so that you can put it back in (delete the //) easily. When you’re changing a bunch of code you can “comment out” entire blocks of your code to keep them preserved as an easy backup if your new plan falls apart. That’s what “commenting out” means.

The error message disappeared. Okay. So it really was throwing a fit about that specific line of code.

3) Get More Specific.

My code was saying “thingOne = thingTwo” and it was throwing an error. So was the problem in thingOne, in thingTwo, or somehow in the relationship between the two of them?

For this I used Debug.Log, which lets you write little messages to yourself. With the line of code still commented out, I wrote a line of “Debug.Log(thingOne);” and tested that. It worked fine. I wrote a line of “Debug.Log(thingTwo);” and tested that. It broke.

So thingTwo was the problem. (Obviously these weren’t actually named thingOne and thingTwo. The variable names have been changed to protect the innocent)

4) Finally, I changed how I was getting access to thingTwo. Honestly I still don’t see why the way I had it before was a problem, but the new way is more direct so it’s probably more stable going forward anyway. I tested the Debug.Log again and it worked, so I uncommented the line I’d commented out, changing the language for how I was getting to thingTwo to match what I’d fixed, and at long last that got rid of the bug.

As huge as all the description is, once I got going on this “best practices” plan I bet the whole thing only took a couple minutes. And it got me out of a problem I’d been banging my head against for upwards of an hour. And that’s why they call ‘em Best Practices. Because they’re better than the other practices.

[programmerhumour]

How to avoid NullReferenceExceptions forever

[kerbaldevteam]

KSP Weekly: The Falcon

Welcome to KSP Weekly! On this day, only 10 years ago, we witnessed the first ever private spacecraft launch into orbit. We are talking, of course, about SpaceX’s Falcon 1, an expendable launch system privately developed and manufactured from the ground up by Elon Musk’s company from 2006 – 2009.

The two-stage-to-orbit rocket used Liquid Oxygen and Rocket Propellant-1 for both stages, the first powered by a single Merlin engine and the second powered by a single Kestrel engine. The vehicle was launched a total of five times. Falcon 1 achieved orbit on its fourth attempt, on September 28, 2008, with a mass-simulator as a payload. On July 14, 2009, Falcon 1 made its final flight and successfully delivered the Malaysian RazakSAT satellite to orbit on SpaceX's first commercial launch (fifth launch overall). Following its fifth launch, the Falcon 1 was retired and succeeded by Falcon 9.

According to SpaceX, the Falcon 1 was designed to minimize price-per-launch for low-Earth-orbit satellites, increase reliability, and optimize flight environment and time to launch. It was also used to verify components and structural design concepts that would be reused in the Falcon 9. SpaceX started with the idea that the smallest useful orbital rocket was the minimum viable product (with about 1000 lbs to orbit), instead of building something larger and more complicated, and then running out of money and going bankrupt. Unlike Falcon 9, the first stage was originally planned to return by parachute to a water landing and be recovered for reuse, but this capability was never demonstrated. The second stage was not designed to be reusable.

One of the keys to SpaceX’s success has been its ability to fail – and move on. Despite setbacks, the company was able to quickly learn from its mistakes, make adjustments, and try again. As a result, within 16 years, SpaceX has gone from conceptualizing privately funded, reusable rockets to launching the most powerful rocket we have seen in nearly half a century. Along the way, SpaceX became the only private company capable of returning a spacecraft from low Earth orbit, which it first accomplished in 2010. The company made history again in 2012 when its Dragon spacecraft became the first commercial spacecraft to deliver cargo to and from the International Space Station. The company also successfully achieved the historic first re-flight of an orbital class rocket in 2017, and the company now regularly launches flight-proven rockets. In 2018, SpaceX began launching Falcon Heavy, the world’s most powerful operational rocket by a factor of two.

Perhaps most importantly, SpaceX has helped to reignite the public’s interest in space. Witnessing their feats and ambitious goals come to fruition certainly has inspired countless people, youth in particular, to pursue math, engineering, aeronautics, and astronomy both academically and professionally. SpaceX has helped leverage efforts by NASA and JPL to enforce the idea that having a career in the space industry – even actually going to space – is as real, tangible, and achievable as any other job that requires focus and hard work.

[Development news start here]

It wasn’t that long ago since Update 1.5 was conceptualized and development began, always with the goal of pushing KSP forward and delivering a substantial new update that will improve the players’ experience. Whether it is with bug fixes, giving existing parts a revamp, or brand new features for both the base game and the expansion, this update has something for everyone. We are far from over with KSP and there’s still plenty to come, but we are now at a point in development where we are confident enough with the development of this update to share with you all that Kerbal Space Program 1.5: Dressed for Success comes out this October.

We improved the burn time indicator by recalculating based on dV and not acceleration. We’ve also added a staging indicator that shows which stages contain the dV needed to complete each part of the maneuver. This will show a red section at the end if there’s not enough dV in the current vessel to complete that maneuver. We’ll continue looking at ways to leverage this dV information going forward. In the extended mode of the burn time indicator two extra lines are shown, allowing you to adjust how much time you want to spend burning before and after the node during the maneuver as well as showing you a countdown for when you need to start burning fuel to do so.

In other news, we continue with the parts revamp effort and this week it is time to put the Probodobodyne RoveMate Command Module in the spotlight. The artist reworked the geometry of the RoveMate, and created a new texture map using diffuse, normal and specular maps for this part. You can see a comparison between the old and new RoveMate in the image below.

The RoveMate Command Module will now be available in 3 variants, each of them inspired by different real-life analogues, such as the Curiosity and the Sojourner rovers. Both the gold and silver variants received a new shader that makes their new tin foil shine and interact with light as other parts we’ve shown. However,  if you look closely you’ll notice that despite the obvious similarities, there are some neat differences in the details: the former has a tighter aluminum cloth appearance, while the latter receives a looser tin foil look. Check out these gifs to see the new White, Silver and Gold RoveMate variants in motion.

Click here to see the high-res images

On top of all of the above-mentioned details, the orientation issue with this part has been corrected and a few new attachment nodes on the sides of this part were added. This will certainly help to expand the creative usage for this part.

The team is also revisiting some relatively new parts included in the Making History Expansion. Such is the case of the FLOOYD Labs’ SM-18 Service Module, which received a modest makeover. For this part the team made a few corrections to the caps’ texture maps and included the shiny shader to the tin foil cap. Check out this gif to see how the new SM-18 Service Module looks in motion.

Click here to see the high-res image 

The team also did some good ol’ bug fixing this week, too! You will be glad to hear that with Update 1.5 you will not experience that annoying NullReferenceException that some players got when saving a mission where the craft files used in vessel situations had been deleted. Kerbals will not explode when resuming a test mission either. Additionally, the normal texture maps of the mobile, Woomerang and Dessert launch pads have been fixed.

[KSP Vault]

This week in the KSP Vault…

Forum users kl0buk and Ferrdo_Kerman built one of the best-looking control panels for Kerbal Space Program we’ve encountered and opened this thread to share the development process of making them.

To celebrate the end of the weekly challenges in the KSP subreddit, Matt Lowne made this video where he talks about his personal experience with the challenges and executes the very first one the subreddit presented.

We encountered this beautiful watercolor depiction of our favorite trio while navigating through the World Wide Web and we wanted to share it with you all. By LazyClock: 

Have you seen cool KSP-related content that you consider worth highlighting? Share it with us and help us give content creators more exposure. :)

Remember that you can also share and download missions on Curse, KerbalX, the KSP Forum and the KSP Steam Workshop.

That’s it for this week. Be sure to join us on our official forums, and don’t forget to follow us on Twitter and Facebook. Stay tuned for more exciting and upcoming news and development updates!

Happy launchings!

*Information Source:

(n.d.). Retrieved from https://usatoday30.usatoday.com/educate/college/careers/Entreps/6-17-05.htm

Chang, K. (2016, September 27). Elon Musk's Plan: Get Humans to Mars, and Beyond. Retrieved from https://www.nytimes.com/2016/09/28/science/elon-musk-spacex-mars-exploration.html

S. (2012, November 28). Company. Retrieved from https://www.spacex.com/about

Falcon Launch Report | Successful launch for Falcon 1 rocket. (n.d.). Retrieved from https://spaceflightnow.com/falcon/004/index.html

Shontell, A. (2013, March 09). Elon Musk Decided To Put Life On Mars Because NASA Wasn't Serious Enough. Retrieved from https://www.businessinsider.com/elon-musks-started-spacex-because-he-wanted-to-put-life-on-another-planet-2013-3

[cyanobotcodes]

Recent Updates

Cloth Production Expanded Patches

Added compatibility for Seeds Please

Fixed recipe for Corduroy in the industrial loom

Fixed missing recipes for burlap yarn

Fixed a NullReferenceException on load

Added a recipe to convert several Textiles+ fabrics into generic cloth

Cyanobot's Genes

fixed a compatibility issue with Geological Landforms subsequent to a recent update to that mod

Upcoming

In approximate order:

Talking Isn't Everything - compatibility patch for Way Better Romance

Talking Isn't Everything - patch for creepjoiners

Toddlers - a few more tweaks/fixes to taking to safety

Cyanobot's Genes - balance adjustments for Wist

Cyanobot's Genes - compatibility patch for Big & Small

Talking Isn't Everything - further compatibility patches

Toddlers - HAR compatibility

[the-text-doctor]

Hello.

Platform: Android

Version: 31.1.5282

Player ID: 5ed83c513300905d2f4598cd

Device ID: 8d00fd38215db04b50fc40e391ad5f35

Device Model: samsung SM-N960U

OS: Android OS 10 / API-29 (QP1A.190711.020/N960USQS9FVC5)

CPU: ARM64

RAM: 5576 MB

GPU: Adreno (TM) 630

Graphics Info: OpenGL ES 3.2 V@415.0 (GIT@fdd61e0, I20154638fb, 1602078382) (Date:10/07/20)

Misc: 0

ServerTime: 2022-04-30_22-08-56

NullReferenceException: Object reference not set to an instance of an object.

Assets.Scripts.Unity.UI_New.DailyChallenge.BossEventCoopScreen+<CreateJoinLobby>d__17.MoveNext ()

System.Threading.ExecutionContext.RunInternal (System.Threading.ExecutionContext executionContext, System.Threading.ContextCallback callback, System.Object state, System.Boolean preserveSyncCtx) (at <00000000000000000000000000000000>:0)

System.Action.Invoke () (at <00000000000000000000000000000000>:0)

System.Threading.Tasks.AwaitTaskContinuation.RunCallback (System.Threading.ContextCallback callback, System.Object state, System.Threading.Tasks.Task& currentTask) (at <00000000000000000000000000000000>:0)

System.Threading.Tasks.Task.Finish (System.Boolean bUserDelegateExecuted) (at <00000000000000000000000000000000>:0)

System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1[TResult].SetException (System.Exception exception) (at <00000000000000000000000000000000>:0)

NinjaKiwi.LiNK.Lobbies.Lobby+<Construct>d__4.MoveNext ()

System.Threading.ExecutionContext.RunInternal (System.Threading.ExecutionContext executionContext, System.Threading.ContextCallback callback, System.Object state, System.Boolean preserveSyncCtx) (at <00000000000000000000000000000000>:0)

System.Action.Invoke () (at <00000000000000000000000000000000>:0)

System.Threading.Tasks.AwaitTaskContinuation.RunCallback (System.Threading.ContextCallback callback, System.Object state, System.Threading.Tasks.Task& currentTask) (at <00000000000000000000000000000000>:0)

System.Threading.Tasks.Task.Finish (System.Boolean bUserDelegateExecuted) (at <00000000000000000000000000000000>:0)

System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1[TResult].SetException (System.Exception exception) (at <00000000000000000000000000000000>:0)

NinjaKiwi.LiNK.Lobbies.LiNKLobbyFactory+<Create>d__2.MoveNext ()

System.Threading.ExecutionContext.RunInternal (System.Threading.ExecutionContext executionContext, System.Threading.ContextCallback callback, System.Object state, System.Boolean preserveSyncCtx) (at <00000000000000000000000000000000>:0)

System.Action.Invoke () (at <00000000000000000000000000000000>:0)

System.Threading.Tasks.AwaitTaskContinuation.RunCallback (System.Threading.ContextCallback callback, System.Object state, System.Threading.Tasks.Task& currentTask) (at <00000000000000000000000000000000>:0)

System.Threading.Tasks.Task.Finish (System.Boolean bUserDelegateExecuted) (at <00000000000000000000000000000000>:0)

System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1[TResult].SetException (System.Exception exception) (at <00000000000000000000000000000000>:0)

NinjaKiwi.LiNK.Endpoint`1+<SendMessage>d__4[T].MoveNext ()

System.Threading.ExecutionContext.RunInternal (System.Threading.ExecutionContext executionContext, System.Threading.ContextCallback callback, System.Object state, System.Boolean preserveSyncCtx) (at <00000000000000000000000000000000>:0)

System.Action.Invoke () (at <00000000000000000000000000000000>:0)

System.Threading.Tasks.AwaitTaskContinuation.RunCallback (System.Threading.ContextCallback callback, System.Object state, System.Threading.Tasks.Task& currentTask) (at <00000000000000000000000000000000>:0)

System.Threading.Tasks.Task.Finish (System.Boolean bUserDelegateExecuted) (at <00000000000000000000000000000000>:0)

System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1[TResult].SetException (System.Exception exception) (at <00000000000000000000000000000000>:0)

NinjaKiwi.LiNK.Net.UwrHttpRequestFactory+<SendAndMonitor>d__7.MoveNext ()

System.Threading.ExecutionContext.RunInternal (System.Threading.ExecutionContext executionContext, System.Threading.ContextCallback callback, System.Object state, System.Boolean preserveSyncCtx) (at <00000000000000000000000000000000>:0)

System.Action.Invoke () (at <00000000000000000000000000000000>:0)

System.Threading.Tasks.AwaitTaskContinuation.RunCallback (System.Threading.ContextCallback callback, System.Object state, System.Threading.Tasks.Task& currentTask) (at <00000000000000000000000000000000>:0)

System.Threading.Tasks.Task.Finish (System.Boolean bUserDelegateExecuted) (at <00000000000000000000000000000000>:0)

System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1[TResult].SetException (System.Exception exception) (at <00000000000000000000000000000000>:0)

NinjaKiwi.LiNK.Net.UwrHttpRequestFactory+<Send>d__8.MoveNext ()

System.Threading.ExecutionContext.RunInternal (System.Threading.ExecutionContext executionContext, System.Threading.ContextCallback callback, System.Object state, System.Boolean preserveSyncCtx) (at <00000000000000000000000000000000>:0)

System.Action.Invoke () (at <00000000000000000000000000000000>:0)

UnityEngine.UnitySynchronizationContext+WorkRequest.Invoke () (at <00000000000000000000000000000000>:0)

--- End of stack trace from previous location where exception was thrown ---

System.Threading.SendOrPostCallback.Invoke (System.Object state) (at <00000000000000000000000000000000>:0)

UnityEngine.UnitySynchronizationContext+WorkRequest.Invoke ()

UnityEngine.UnitySynchronizationContext:Exec()

<What the..?>