The Steam Intergalactic Summer Sale continues! For the next eleven days, take advantage of huge savings throughout our store on over ten thousand games. You can also help unlock free games by playing our Summer Saliens Game.

Today’s Featured Deals include:

The Elder Scrolls Franchise – Up to 50% off
Tomb Raider Franchise – Up to 89% off
Battletech – 20% off
The Long Dark – 75% off
Star Trek: Bridge Crew – 50% off
Sid Meier’s Civilization Franchise – Up to 75% off
Mad Max – 75% off
Portal 2 – 90% off
and many more

Along with the sale is the Summer Saliens Game. Team up with other Saliens to fight The Duldrumz on different planets and free the abducted games. Gain XP as you battle, level up, unlock new abilities, and win cosmetic items to deck out your Salien. Plus, get Summer Sale Trading Cards just for playing.

Choose to battle on a planet that piques your interest and you’ll automatically be entered for a chance to win one of its rewards when it’s conquered. The longer your Salien spends on a planet the higher your chances of winning! The groups with the most tiles when a planet is taken will get to plant their flag as conquerors, undoubtedly gaining Saliverse-wide fame in the process.

The Steam Intergalactic Summer Sale will run until 10 AM Pacific, July 5th. Complete information can be found HERE.

Brian Behlendorf, Executive Director of the Linux Foundation’s Hyperledger project, has been named one of the top 10 influential voices in the blockchain world, in a New York Times commentary titled “The People Leading the Blockchain Revolution.” Blockchain technology—which encompasses smart contracts, distributed ledgers, and more—is already transforming contracts, payment processing, asset protection, and supply chain management.

In the article, Behlendorf is credited with driving the evolution and widespread adoption of numerous essential blockchain platforms and tools.

“Mr. Behlendorf has helped bring in other big names who are helping to make Hyperledger the focus of much of the corporate and governmental interest in blockchains today,” the Times reports.

Read more at The Linux Foundation

It’s a big day for Halo – today, SHOWTIME president and CEO David Nevins announced the network has ordered a 10-episode season based on the legendary video game franchise!

In its adaptation for SHOWTIME, Halo (working title) will take place in the universe that first came to be in 2001, dramatizing an epic 26th-century conflict between humanity and an alien threat known as the Covenant. Kyle Killen (Awake) will serve as executive producer, writer and showrunner. Rupert Wyatt (Rise of the Planet of the Apes) will direct multiple episodes and also executive produce the hour-long series which enters production in early 2019.

“Halo is our most ambitious series ever, and we expect audiences who have been anticipating it for years to be thoroughly rewarded,” said Nevins. “In the history of television, there simply has never been enough great science fiction. Kyle Killen’s scripts are thrilling, expansive and provocative, Rupert Wyatt is a wonderful, world-building director, and their vision of Halo will enthrall fans of the game while also drawing the uninitiated into a world of complex characters that populate this unique universe.”

“This is a truly exciting moment for the Halo franchise,” stated Kiki Wolfkill, head of Halo Transmedia at 343 Industries. “Together with our creative and production partners at SHOWTIME and Amblin Television, the Halo television series will represent new and exciting way for fans to enter and engage with the Halo universe. We can’t wait to share more on what’s ahead.”

Halo will be executive produced by Killen, Wyatt and Scott Pennington, along with Justin Falvey and Darryl Frank for Amblin Television. The series will be distributed globally by CBS Studios International.

For all things Halo and the recently announced Halo Infinite, be sure to check out Halo Waypoint and stay tuned to Xbox Wire.

We’ve announced additional keynotes at Open Source Summit North America, including:

• Van Jones, President & Founder of the nonprofit, Dream Corps; CNN Contributor; Best-Selling Author; Human Rights, Education and Clean Energy Advocate
• Austen Collins, Founder & CEO, Serverless Inc.
• Linus Torvalds, creator of Linux and Git, in conversation with Dirk Hohndel, VP & Chief Open Source Officer, VMware

View the Full Schedule >>

The event also features the Open Collaboration Conference where ecosystem leaders learn to navigate open source transformation with sessions covering compliance, community leadership and open source program office management in the new TODO track. The Diversity Empowerment Summit is also featured, which highlights the ways in which the community can benefit from expanding diversity and inclusion practices.

Register now to save $150 through July 21.

Register Now >>

Read more at The Linux Foundation

I’m four months into the curriculum at Holberton School and we’ve solved multiple problems using the malloc, realloc, calloc and free functions in the C programming language. What better way to build a solid foundation of how memory gets allocated then to write a technical post on the stack versus the heap?

This article explains in depth:

What are the five segments of memory?

What is the stack?

What is the heap?

How does understanding the two make you a better software engineer?

What are the five segments of memory?

When we write applications, files, or any logic that is typed in an editor and executed on the computer, the computer has to allocate memory for the program to run. The memory that is assigned to a program or application in a computer can be divided into five parts. The amount of memory that get’s assigned to an application depends on the computer’s architecture and will vary across most devices, but the variable that remains constant is the five parts of an application’s memory which are the heap, stack, initialized data segment, uninitialized data segment, and the text segment.

The initialized data segmentconsists of all the global and static variables that are initialized when a file gets compiled. The uninitialized data segment consists of all global and static variables that are initialized to zero or do not have explicit initialization in source code.

At Holberton, most of the time we are not concerned about the uninitialized data segment because when we compile our programs with gcc, we use the flags, -Wall -Wextra -pedantic -Werror and we use an internal stylistic checker called betty which treats warning as errors when uninitialized variables are present. Having unused variables in our programs gets flagged and is not a best practice. The text segment, also known as the code segment, contains the machine instructions which make up your program. The text segment is often read-only and prevents a program from accidentally modifying its instructions.

What is the stack?

The stack is a segment of memory where data like your local variables and function calls get added and/or removed in a last-in-first-out (LIFO) manner. When you compile a program, the compiler enters through the main function and a stack frame is created on the stack. A frame, also known as an activation record is the collection of all data on the stack associated with one subprogram call. The main function and all the local variables are stored in an initial frame.

Program vs Stack usage

In the picture above, we have one stack frame on the stack that holds the main function, along with the local a, b and sum variables. After using the printf() function the frame we created along with the local variables are only accessible in memory for the duration of the frame are no longer accessible after returning the 0 value from the function.

What happens with the stack when we call multiple functions? To illustrate the stack in it’s LIFO manner, let’s solve a problem using recursion. When we call multiple functions in our application, we use multiple stack frames in a last-in-first-out approach meaning that the last stack frame we’ve created on the stack is the first stack that will be released after the function is done executing its logic. Let’s go over an example of printing out the name “Holberton” recursively and show how our code affects the stack memory segment.

Yes, I have a whiteboard on the back of my door at my house.

When we compile our code using gcc _putchar.c 0-puts_recursion.c 0-main.c , the compiler enters our program through int main(void) and creates a frame with the function int main(void) and _puts_recursion("Holberton") living on that frame as illustrated on the image above. When the compiler runs into the _puts_recursion() function, it calls that function and creates another stack frame on top of the previous stack frame where int main(void) lives. We are now in our second stack frame in our program and have entered in the _puts_recursion(char *s)function where *s is equal to 'H' and is only accessible in that stack frame. Because 'H' does not equal '\0' , we will continue with our function calls and execute the _putchar('H') function and enter into the same function _puts_recursion(++s). The argument ++s moves the memory address of the *s one byte because the size of a char is 1 byte on our machine, and now _puts_recursion is calling the function as _puts_recrusion('o') . Each time the _puts_recursion function is called, a new stack frame is put on the stack until we hit the terminating condition which is if (*s == '\0').

Every time a new stack frame is created, the stack pointer moves with it until it reaches the terminating condition. A stack pointer is a small register that stores the address of the last program request in a frame. When we hit the terminating condition, we execute our logic, then start to unwind the stack or pop off stack frames in the last-in-first-out manner until we reach out return(0) logic in the int main(void) function in our first stack frame.

If you don’t have a terminating case for the recursive example above, the stack will continue to grow in size adding additional stack frames on-top of each other, moving the stack pointer upward on each call, against the heap, which will be explained in the next section. In a recursive function , if there is no valid terminating condition, the stack will grow until you’ve completed consumed all the memory that’s been allocated for your program by the operating system. When the stack pointer exceeds the stack bound, you have a condition called stack overflow. Bad things happen when you have a stack overflow.

Let’s first refer back to the other four segments of your application’s memory which were the uninitialized and initialized data segments, text segment and stack segment. These four segments have a constant memory size during compilation. The memory size for these four segments is predetermined by your operating system before compiling your programs. When software engineers write programs that consume large amounts of memory from a machine, they have to consider where and how much memory is being consumed in their application.

The max stack size is constant and predetermined before a program is compiled. At Holberton, we use a Linux Ubuntu/Trusty64 distributions. To find information about the stack size and other neat limits, type the command below into your terminal.

ulimit -a

Where ulimit is a function that gets and sets user limits and the -a flag lists all the current limits.

Stack size is 8.192MB of memory.

If the stack is limited in size and a program needs more memory for it to execute, where can a software engineer pull memory from for his/her application? This is where the heap comes into play.

What is the heap?

The heap is the segment of memory that is not set to a constant size before compilation and can be controlled dynamically by the programmer. Think of the heap as a “free pool” of memory you can use when running your application. The size of the heap for an application is determined by the physical constraints of your RAM (Random access memory) and is generally much larger in size than the stack.

We use memory from the heap when we don’t know how much space a data structure will take up in our program, when we need to allocate more memory than what’s available on the stack, or when we need to create variables that last the duration of our application. We can do that in the C programming language by using malloc, realloc, calloc and/or free. Check out the example below.

Allocating 4000 bytes of memory to our program, then releasing it.

We allocate memory from the heap using the malloc() function. The argument we want to include in malloc is the amount of memory we want to allocate to our application, in bytes. Malloc returns a void pointer that is type casted into an integer pointer that now points to the first address in memory for our 4000 byte long memory. We can now store information in those memory addresses and do as we please to that information for the duration of our program or for the duration of our function because we have a pointer that references the first memory address from the newly allocated heap memory.

If you aren’t intentionally creating variables that last the duration of your application from the heap, you always want to release the memory back to the machine using the free() function. If you don’t release the memory using the free() function, you have memory that will persist throughout your program. If we do not release the memory from our program before terminating the application, our application has memory leaks. If your application has enough memory leaks, it can consume more memory than is physically available and can cause programs to crash. This is why we use a program called valgrind. Valgrind is easy to use and checks for memory leaks.

Valgrind being used. 4,000 bytes allocated. 0 bytes leaks

Another thing to consider while using the heap, the pointer variables created on the heap are accessible by any function, anywhere in your program, as long as the memory is still persistent and hasn’t been free.

How does understanding the stack and heap make you a better software engineer?

If you understand the advantages and disadvantages of using the stack vs the heap for your application, then it gives you a strategic advantage for creating scalable programs. You, the programmer, have to decide when to use memory from the stack vs heap based on each problem you are trying to solve.

If you have a variable like an array or struct that needs to be stored in a large block memory, needs to persist throughout the lifetime of your application and could change in size throughout the duration of your program, then you should allocate it from the heap.

If you need to create helper functions with variables that only persist within the lifetime of the function, then you should allocate memory from the stack. Memory from the stack is easier to keep track of because the memory is only locally available in the function call which does not persist after the function is completed and is managed by the CPU.

Photo credit: Gribble Lab

Questions, comments or concerns, feel free to comment below, follow me or find me on Twitter @ NTTL_LTTN.

References:

My Code School. (February 23rd, 2013). Pointers and dynamic memory — stack vs heap. . Retrieved from https://www.youtube.com/watch?v=_8-ht2AKyH4

Paul Gribble (2012). C Programming Boot Camp — 7. Memory: Stack vs Heap. [Blog post]. Retrieved from https://www.gribblelab.org/CBootCamp/7_Memory_Stack_vs_Heap.html#orgheadline1

GeeksforGeeks. Memory Layout of C Programs. [Blog post]. Retrieved from https://www.geeksforgeeks.org/memory-layout-of-c-program/

Sandra Henry-Stocker. (November 18th, 2012). NETWORK WORLD — Setting limits with ulimit. [Blog post]. Retrieved from https://www.networkworld.com/article/2693414/operating-systems/setting-limits-with-ulimit.html

Valgrind Developers (2000–2017). Valgrind. Retrieved from http://valgrind.org/

Die.net Linux Documentation. Retrieved from https://linux.die.net/

Taken a Live Photo on your iPhone or iPad and want to share it around on social media as a GIF, potentially creating a meme in the process? AppleInsider shows how to convert the clip into one of the most commonly used animated image formats found online.

Introduced in 2015 in iOS 9, Live Photos is a feature of the iOS camera that records the period of time surrounding the moment when the user takes a photograph. Along with the still image, Live Photos can also play the 1.5 seconds before and after the shot as a 15fps video, telling viewers the story about the shot.

Shortly after its creation, various apps and services started to support the image type, enabling them to be shared with other users. There are also options in the Photos app to share the Live Photo with others on social networks and messaging apps, and for most people, that’s more than enough for their needs.

In cases where an app or service simply won’t accept a Live Photo as an image or animation, or if you want to slightly change how it appears, the best option is to create an animated GIF.

Creating the Image

Load up the Photos app and select the Albums tab. In that section, select the Live Photos folder, then tap the specific Live Photo you want to use to bring it fullscreen.

Swipe upwards in the middle of the screen to bring up extra information about the shot. The main element we are interested in is the animation effects selection.

There are four options here, with Live effectively leaving the image as it is, playing just once. Another is Long Exposure, which combines all the frames of the Live Photo into a single image, which can create some artistic effects. Ignore both of these options.

For this, we are interested in the Loop and Bounce options. Loop continuously plays the animation, while Bounce will constantly play the clip forwards then backwards. Select one of these two options.

Navigate back to the Albums tab and select a folder called Animated, which contains any and all animated GIF-style content created on the iPad. If the folder didn’t exist previously, Photos will automatically create it.

Opening the animation in the folder will display the created GIF file. Photos will also display in the top-left corner what kind of animation option was selected for the image.

At this point, the image can be shared via the normal sharing options, or you could email it to yourself as a GIF file.

Further Notes

While this may be seen as a waste of time creating a GIF rather than directly sharing, creating the animation before sharing can help prevent some issues. Not all apps will accept a Live Photo directly as an animation

For example, adding a Live Photo as an attachment in Gmail will result in a JPEG file instead of a GIF, while sending the version from the Animation folder returns the intended GIF.

There is also the added benefit of being able to control how it will be displayed on other platforms, as there’s no guarantee that it will automatically loop on your chosen service.

Users wanting more control over how GIFs appear, or to create GIFs from video clips, can find a wealth of apps in the App Store for the task.

By Collin MacGregor 28 Jun 2018

This October XRDC is coming to San Francisco, and it promises to be the premier conference for AR, VR, and MR innovation! 

As part of XRDC’s Education & Training track of talks, Boeing lead technical integrator Eric Spalding will be presenting a fascinating session all about “VR/AR Challenges for Training Environments” that promises to dig deep into Spalding’s work leading an R&D team researching AR and VR training in aerospace industries.

According to Spalding, AR and VR technologies could be extraordinarily disruptive to how training is performed. For the first time, students can be immersed in an environment that is easily deployable at low cost and without the dangers of real hardware.

However, for broad adoption, there are challenges to overcome that entertainment applications can more easily avoid, such as density of environments and interaction haptics.

With that in mind, Spalding’s XRDC presentation will provide an overview of various challenges facing AR/VR adoption in the training space and challenges attendees to develop solutions that could increase the overall AR/VR market. It promises to be fascinating if you’re at all interested (or invested) in the AR/VR/MR space, so don’t miss it!

XRDC is happening October 29th and 30th in San Francisco at the Westin St. Francis Hotel. Now that registration is open, you’ll want to look over XRDC passes and prices and register early to get the best deal! 

For more information about XRDC, which is produced by organizers of the Game Developers Conference, check out the official XRDC website. You can also subscribe to regular XRDC updates via email, Twitter and Facebook.

Gamasutra, XRDC, and GDC are sibling organizations under parent UBM Americas