Educators from across the globe are bringing their passions, experiences and big-change ideas together again for the 2018 ISTE Conference and Expo, kicking off this week in Chicago, Illinois. And if forward-thinking teachers and time-saving tech advancements are going to be there, that means What’s New in EDU is going to be there too.

We’re debuting brand new episodes of What’s New in EDU, our round-up of the latest efforts and products from Microsoft Education, throughout the week of ISTE. You can tune in to each episode live, even if you’re #notatISTE, so keep an eye on the schedule below:

What’s New in EDU: Live from ISTE on Monday: 5:00 PM CDT on Facebook Live

What’s New in EDU: Live from ISTE on Tuesday: 5:00 PM CDT on Facebook Live

What’s New in EDU: Live from ISTE on Wednesday: 5:00 PM CDT on Facebook Live

There’s a lot of exciting news to cover this week, including our announcement of Minecraft: Education Edition’s Update Aquatic and our partnership with BBC Learning on new, cost-effective STEM lesson plans. We also have an update on free workshops coming to Microsoft Store locations that help educators attain Microsoft Innovative Educator (MIE) certification.

If you’re an educator:

Office 365 Education helps create engaging learning experiences for today’s classrooms. Using the products you already know and love like Word, OneNote, and PowerPoint, reach students with features that help you create personalized learning experiences.

• Dictation: This simple yet transformative tool helps students write freely and conquer the blank page using their voice. Dictation is now available for Word and PowerPoint on Win32 as well as OneNote for Windows 10.

New OneNote Sticker Packs: Have you ever been to the bottom of the Mariana Trench, the deepest canyon in the world? Did you know that an octopus can collect shells to make armor to fight off sharks? We’ve created four new sticker packs that explore the ocean and the marine life that call it home! We take a look at coral reefs, tide pools, the deepest parts of the ocean, and those larger species that need a little more space in the open ocean.

Learning Tools:  13,000,000 people round the globe regularly use Learning Tools to help them achieve more in school and at home. As part of Learning Tools, Immersive Reader implements proven techniques to improve reading for learners regardless of their age or ability.

• Parts of Speech symbols: Teachers and students have the option to enable symbols for nouns, verbs, and adjectives over the highlighted part of speech. This is especially useful for readers who are color blind.
• Adverbs: The Immersive Reader has had the ability to highlight important parts of speech, including nouns, verbs, and adjectives. We listened to valuable feedback from teachers that adverbs are also an important part of speech that should be highlighted and now adverbs are available in over 10 languages.

 

Microsoft Teams is the digital hub that brings conversations, content, assignments, and apps together in one place. Educators can create collaborative classrooms, connect in professional learning communities, and communicate with school staff – all from a single experience in Office 365 Education.

This month, Teams celebrates its first-year anniversary! Read more about the news, including new educator stories – and discover free teacher training materials.

• Rubrics Grading: Utilize rubric grading and skills-based grading of your assignments making it easier to deliver feedback to your students. Students will also be able to see how they’ll be assessed upfront, before they start working on the assignment. Teachers can save a lot of time with a grading tool that’s easily applied to multiple assignments at once.

• Forms in Assignments: In Assignments, you’ll be able to add a Form to a new assignment for your students to fill out and return. Leverage features of Forms reporting functionality, like auto-grading, feedback, and scores, directly in the Assignments grade book and keep track of scores across many Forms-powered quizzes.

• Join Codes: Create a simple code for members to join your Class, PLC, or Staff team. This makes it easy for many people to join your team all at once. Display the code in ‘projector mode’ so that everyone in the classroom can see it and join the team.
• Reusing a team as a template: Teachers can reuse an existing team as a template when creating a new team, then customize what they want to copy over: channels, team setting, apps, and even users.
• Mute all students: There’s a time for conversation, and there’s a time for focus. You can now pause students from posting in the conversation tab.
• Page locking in OneNote assignments – For teachers creating OneNote assignments, the pages of the student will now automatically “lock” as read only when the due date/time passes. The teacher can still edit and annotate these OneNote assignment pages with feedback.
• Archive teams: Safely store your Class, PLC, or Staff team content in read-only mode. Easily reference archived teams while you are setting up your Teams experience for the next school year.

Open Up Resources:  Open Up Resources is a nonprofit working to develop the highest quality full-course Open Educational Resources (OER) curricula, standards-aligned, and provided for free to promote instructional equity. This curriculum was developed by Illustrative Mathematics, and currently covers 6th – 8th Grade Math. Recently, EdReports gave this curriculum their highest rating ever.

 OneNote empowers teachers and students to capture information and stay organized in their digital notebook.  OneNote allows students to organize their notes, ideate with others, and sync their notes seamlessly via the cloud.

• Math Assistant Understanding the steps of a complex math problem is key to finding a solution. Math Assistant in OneNote Online helps this process by showing solution steps, as well as providing a graph for easier visualization. Read more about Math Assistant in OneNote online here.

OneNote Class Notebooks helps teachers capture and organize class content, create and deliver interactive lessons, provide feedback, and collaborate. Teachers can create a personal workspace for every student, a content library for handouts, and a collaboration space for lessons and creative activities. This school year, 25,000,000 student notebooks have been created!

• Page Locking: Page locking allows teachers to prevent unwanted editing by students. Teachers can lock pages as read-only after giving feedback to the student but can still edit the locked pages themselves. Read more about Page locking in OneNote Class Notebooks here.
• Teacher Transfer: This highly requested tool allows school IT professional to help transfer Class Notebooks from one teacher to another or to different schools when teachers change positions, saving valuable time and information.

Page Locking in OneNote for Windows 10

Microsoft Forms helps teachers quickly create polls, quizzes, and assessments, and see results as they come in. Microsoft Forms is simple to use, works on any browser and device, and lets you assign points for automatic grading.

• Math Quiz: With additional tools to create math questions and worksheets, teachers can broaden the type of questions they ask in Forms to better assess Math skills. Read more about Math Quiz in Microsoft Forms here.

Microsoft Sway helps teachers and students easily create immersive, interactive presentations with images, text, videos, and other multimedia.

• Refreshed iOS app: Updates to the iOS app include new commands that make it a breeze to add and organize content on-the-go.  Students and teachers will be able to easily incorporate their mobile captures, use drag-and-drop, tap to resize content, and instantly work together by using Sways Near Me.  Read more about the updates in our latest blog post.

Microsoft MakeCode brings computer science to life for all students with fun projects, immediate results, and both block and text editors for learners at different levels. MakeCode takes a unique approach to Computing Education by combining the magic of Making with the power of Code as a way to make learning about computers and technology more accessible, and interesting to a wider audience of students.

• MakeCode for LEGO MINDSTORMS: Microsoft MakeCode provides a very easy on-ramp into robotics with LEGO MINDSTORMS EV3 by providing students with both a block-based, and text-based coding environment.  And because it’s browser-based, schools can use MakeCode for MINDSTORMS on any computer. For more details view this blog post.

 

 The Microsoft Photos app features a built-in video editor, making it easy for you and your students to create movies using photos, video clips, music, 3D models, and Hollywood-style special effects. Whether it’s a group history project, a lab report, or a music video just for fun, you can quickly sequence your project, add titles, drop in music, and enhance your story with special effects.

• Timeline scrollbar: The new timeline scrollbar makes it easy to jump to a specific month or year to see the photos and videos you captured on a that date. The scrollbar is tailored to your collection, showing you at a glance where your biggest capture sessions have been and how your photos and videos are distributed over time.

Change the date on a photo or video: Have you ever taken pictures on a camera that didn’t have the date and time set correctly? Now it’s easy to get that media showing up correctly in your collection. Just right-click on an image or video to change the date.

Microsoft Store locations in the U.S. are offering free MIE workshops:

You might already be familiar with the Microsoft Innovative Educator (MIE) program, which teaches educators of all levels how to integrate technology and Microsoft tools into the classroom to improve their students’ learning experience. This program was previously only offered online, but now for the first time ever, Microsoft Store locations in the U.S. are offering free MIE workshops for educators who prefer an in-person learning experience.

Workshops are taught by associates who are certified MIE Experts, and just like the online MIE training programs, educators earn credit to become a certified MIE. To learn more, educators are invited to stop in anytime at their local Microsoft Store and speak with the Community Development Specialist.

If you focus on IT:

Intune for Education makes it easy to set up and manage Windows 10 devices in just a few steps, including deploying apps or settings to users, and managing shared devices.

• User and Device Details Pages: At a basic level, administrators want to be sure that everything is working as expected so that the in-classroom experience is focused on learning. The basic question we hear from these admins is: “When student ‘X’ signed in to device ‘Y’, what should have been applied and what was actually applied?”  To help resolve this requirement, we have added a key feature for admins: Once they find the user/device in the management console, they can now see which settings and apps should be applied plus the deployment status for a user/device.

School Data Sync (SDS) simplifies class creation and management in Office 365. SDS reads from your Student Information Systems (SIS) and creates classes and groups for Microsoft Teams, OneNote Class Notebooks, Intune for Education, and third-party applications. Best of all, it’s free!

• Education Security Groups: SDS creates new Education Security Groups by default. The new groups will include the All Teachers, All Students, Teachers of School, and Students of School. These groups can be used for Intune for Education device policy, Group Based Licensing, Conditional Access Policy, and several other O365 security management features.
• Expired Class Management: SDS provides options to rename expired classes, remove student access from expired classes. This new experience simplifies class management for term transition and back-to-school cycles.

To learn more about Microsoft Education and our tools and technology that help foster inclusion and support personalizing learning for every student, click here.

We know you’re all secretly playing Fortnite on your iPhones or Tablets right now. The Battle Royale sensation earns hundreds of millions in dollars nearly every month and the playerbase has grown to 125 million. It’s certainly not me who’s been spending all that money. God knows what will happen when it finally comes to Android.

What better way to show your clear & undeniable appreciation for this masterpiece by displaying your affection via a snazzy, on-message wallpaper for your phone. Your first port of call could always be this iOS app we found cunningly titled Fortnite Wallpapers. It’s iOS Universal, it’s free, and it also has a collection of phone (and tablet) art that you can use show your allegiance. Thank you Matthew Nelson for trying to make us redundant.

If you’re happy to let us help you though, using top-secret investigative techniques (Google), we’ve scoured the internet to find some of the best examples of Fortnite wallpaper.

< I’M A LLAMA
Source:  Pinterest

Did you ever see The Emperor’s New Groove? Man that was a great film. Some good, clean Disney humour there, and all about a guy who gets turned into a Llama. Speaking of llamas, we managed to find a rather artisitc version of the Fortnite llama, in wallpaper form. Don’t say we never do anything nice for you.

Nerves of Steel >
Source: Progamesguide

We like this one because A/ Chrome and B/ it’s actually a really good character render. There’s a lot of detail, some really bold colours (animated red hair looks pretty great). Also, there’s a lot of sass in that smile of hers. It’s almost like she’s saying “Aww yeah, it’s on,” before she shoots lasers out of her eyes and melts your face.

< Rust Lord
Source: iphonehacks 

One thing that contributes to Fortnite‘s appeal is the customisation factor. Whether you win it in-game or pay real money, you can find a character skin that best suits your personality or identity and equip it. It’s a very pure form of digital expression that often gets over-looked, and an often misunderstood part of what drives free-to-play business models.

This is wallpaper features a skin that released as part of the third season of Battle Pass. It’s called ‘Rust Lord’ and is a purple rarity skin.

CrossOver >

Source: Progameguides

The cross-over event with Avengers: Infinity War may be over, but that doesn’t mean you can’t forever remember that one time Thanos was in Fortnite. 

He couldn’t build or carry weapons (except when he could), but he was strong and surprisingly fun to play as. Was this the best cross-over event of all time? Probably. 

< Plain & Simple
Source:  Pinterest

As well as featuring a great shade of purple, this wallpaper is great because it is what is – someone with this clearly likes Fortnite, and they’re not afraid to tell the world about it.  

Festive Fun >
Source: HDQWalls

Christmas is long behind us, but should this Fortnite business last until the 2018 holiday season what better way to get into the festive spirit with a festively themed background. There’s a Christmas tree in the background and everything.

Fun fact, the original image shows the Fortnite crew facing off against zombies.

< Angelic
Source: HDQWalls / Dodonozore34

If you’ve ever won a game of Fortnite, you’ll know it’s a transcendent moment. Not only did you managed to survive, you managed to beat everyone else whilst doing it. Winning is like ascending to a higher plain of existence which, unlike Redbull, is a process which legitimately does give you wings. Here’s a Frotnite wallpaper that has one of the character skins with wings.

Don’t Mess with Me >
Source: Pinterest

Alternatively, you might just want to show everyone that you mean business. This wallpaper features another one of the character skins available in the game. You can tell by the fact that his arms are crossed that he’s not going to take any nonsense from anybody. Also, the black background and colour scheme makes everything a lot more dramatic than it needs to be.

< Birds-Eye View
Source: Alphacoders

Perhaps you’d like something a bit subtler and understated. There’s nothing like a bit of scenery to draw people’s attention and spark conversation. This 3D snapshot/recreation of the Battle Royale map throws up some iconic locales, as well as the looming storm in the background. You may not be loud-and-proud with this one, but anyone who knows what they’re looking like will be secretly sending you their respect.

The Devil Makes Work For Idle Hands >
Source: Epic Games Forum

To finish off the list, this is the only wallpaper on the list we can actually attribute to an actual author.

Epic forum user Whitesushi was apparently bored one day, so decided to make a phone wallpaper themed on Fortnite’s PVE mode. It’s definitely the best quality out of the list, although perhaps not as memorable (or as on point).

Have you found any neat phone wallpapers that use for Fortnite? Or any game, really – why not share them with us in the comments!

What is Python?

Python is an interpreted, interactive object-oriented programming language; it incorporated modules, classes, exceptions, dynamic typing and high level data types. Python is also powerful when it comes to clear syntax. It is a high-level general-purpose programming language that can be applied to many different classes of problems — with a large standard library that encapsulates string processing (regular expressions, Unicode, calculating differences between files), Internet protocols (HTTP, FTP, SMTP, XML-RPC, POP, IMAP, CGI programming), software engineering (unit testing, logging, profiling, parsing Python code), and operating system interfaces (system calls, filesystems, TCP/IP sockets). Here are some of Python’s features:

• An interpreted (as opposed to compiled) language. Contrary to C, for example, Python code does not need to be compiled before executing it. In addition, Python can be used interactively: many Python interpreters are available, from which commands and scripts can be executed.
• A free software released under an open-source license: Python can be used and distributed free of charge, even for building commercial software.
• Multi-platform: Python is available for all major operating systems, Windows, Linux/Unix, MacOS X, most likely your mobile phone OS, etc.
• A very readable language with clear non-verbose syntax
• A language for which a large variety of high-quality packages are available for various applications, from web frameworks to scientific computing.
• A language very easy to interface with other languages, in particular C and C++.
• Some other features of the language are illustrated just below. For example, Python is an object-oriented language, with dynamic typing (an object’s type can change during the course of a program).

What does it mean to be an object-oriented language?

Python is a multi-paradigm programming language. Meaning, it supports different programming approach. One of the popular approach to solve a programming problem is by creating objects. This is known as Object-Oriented Programming (OOP).

An object has two characteristics:
1) attributes
2) behavior

Let’s take an example:

Dog is an object:
a) name, age, color are data
b) singing, dancing are behavior

We call data as attributes and behavior as methods in object oriented programming. Again:

Data → Attributes & Behavior → Methods

The concept of OOP in Python focuses on creating reusable code. This concept is also known as DRY (Don’t Repeat Yourself). In Python, the concept of OOP follows some basic principles:

Inheritance — A process of using details from a new class without modifying existing class.
Encapsulation — Hiding the private details of a class from other objects.
Polymorphism — A concept of using common operation in different ways for different data input.

Class

A class is a blueprint for the object.

We can think of class as an sketch of a dog with labels. It contains all the details about the name, colors, size etc. Based on these descriptions, we can study about the dog. Here, dog is an object.

The example for class of dog can be :

class Dog: pass

Here, we use class keyword to define an empty class Dog. From class, we construct instances. An instance is a specific object created from a particular class.

A Class is the blueprint from which individual objects are created. In the real world we often find many objects with all the same type. Like cars. All the same make and model (have an engine, wheels, doors, …). Each car was built from the same set of blueprints and has the same components.

Object

Think of an object in Python as a block of memory, and a variable is just something that points/references to that block of memory. All the information relevant to your data is stored within the object itself. And the variable stores the address to that object. So it actually doesn’t matter if you reassign a variable pointing to an integer to point to a different data type.

>>> a = 1

>>> a = "I am a string now"

>>> print(a)

I am a string now

Every object has its own identity/ID that stores its address in memory. Every object has a type. An object can also hold references to other objects. For example, an integer will not have references to other objects but if the object is a list, it will contain references to each object within this list. We will touch up on this when we look at tuples later.

The built-in function id() will return an object’s id and type() will return an object’s type:

>>> list_1 = [1, 2, 3]

# to access this object's value

>>> list_1 [1, 2, 3]

# to access this object's ID

>>> id(list_1) 140705683311624

# to access object's data type

>>> type(list_1) <class 'list'>

So, an object (instance) is an instantiation of a class. When class is defined, only the description for the object is defined. Therefore, no memory or storage is allocated.

The example for object of class Dog can be:

obj = Dog()

Here, obj is object of class Dog.

Suppose we have details of Dog. Now, we are going to show how to build the class and objects of Dog.

class Dog:

#class attribute species = "animal"

# instance attribute def __init__(self, name, age): self.name = name self.age = age

# instantiate the Dog class

blu = Dog("Blu", 10)

woo = Dog("Woo", 15)

# access the class attributes

print("Blu is an {}".format(blu.__class__.species))

print("Woo is also an {}".format(woo.__class__.species))

# access the instance attributes

print("{} is {} years old".format( blu.name, blu.age))

print("{} is {} years old".format( woo.name, woo.age))

When we run the program, the output will be:

Blu is an animal

Woo is also an animal

Blu is 10 years old

Woo is 15 years old

In the above program, we create a class with name Dog. Then, we define attributes. The attributes are a characteristic of an object.

Then, we create instances of the Dog class. Here, blu and woo are references (value) to our new objects.

Then, we access the class attribute using __class __.species. Class attributes are same for all instances of a class. Similarly, we access the instance attributes using blu.name and blu.age. However, instance attributes are different for every instance of a class.

Let’s try to understand how value and identity are affected if you use operators “==” and “is”

The “==” operator compares values whereas “is” operator compares identities. Hence, a is b is similar to id(a) == id(y), but two different objects may share the same value, but they will never share the same identity.

Example:

>>> a = ['blu', 'woof']

>>> id(a)

1877152401480

>>> b = a

>>> id(b)

1877152401480

>>> id(a) == id(b)

True

>>> a is b

True

>>> c = ['blu', 'woof']

>>> a == c

True

>>> id©

1877152432200

>>> id(a) == id©

False

Hashability

What is a hash?

According to Python , “An object is hashable if it has a hash value which never changes during its lifetime”, if and only if the object is immutable.

A hash is an integer that depends on an object’s value, and objects with the same value always have the same hash. (Objects with different values will occasionally have the same hash too. This is called a hash collision.) While id() will return an integer based on an object’s identity, the hash() function will return an integer (the object’s hash) based on the hashable object’s value:

>>> a = ('cow', 'bull')

>>> b = ('cow', 'bull')

>>> a == b

True

>>> a is b

False

>>> hash(a)

6950940451664727300

>>> hash(b)

6950940451664727300

>>> hash(a) == hash(b)

True

Immutable objects can be hashable, mutable objects can’t be hashable.This is important to know, because (for reasons beyond the scope of this post) only hashable objects can be used as keys in a dictionary or as items in a set. Since hashes are based on values and only immutable objects can be hashable, this means that hashes will never change during the object’s lifetime.

Hashability will be covered more under the mutable vs immutable object section, as sometimes a tuple can be mutable and how does that change values and understanding of mutable objects and immutable objects.

To summarize, EVERYTHING is an object in Python the only difference is some are mutable and some immutable. Wait but what kind of objects are possible in Python and which ones are mutable and which ones aren’t?

Objects of built-in types like (bytes, int, float, bool, str, tuple, unicode, complex) are immutable. Objects of built-in types like (list, set, dict, array, bytearray) are mutable. Custom classes are mutable. To simulate immutability in a class, one should override attribute setting and deletion to raise exceptions.

Now how would a newbie know which variables are mutable objects and which ones are not? For this we use 2 very handy built-in functions called id() and type()

What is id() and type()?

Syntax to use id()

id(object)

As we can see the function accepts a single parameter and is used to return the identity of an object. This identity has to be unique and constant for this object during the lifetime. Two objects with non-overlapping lifetimes may have the same id() value. If we relate this to C, then they are actually the memory address, here in Python it is the unique id. This function is generally used internally in Python.

Examples:

The output is the identity of the object passed. This is random but when running in the same program, it generates unique and same identity. 

Input : id(2507)

Output : 140365829447504

Output varies with different runs

Input : id("Holberton")

Output : 139793848214784

What is an Alias?

>>> a = 1

>>> id(a)

1904391232

>>> b = a #aliasing a

>>> id(b)

1904391232

>>> b

1

An alias is a second name for a piece of data. Programmers use/ create aliases because it’s often easier and faster to refer data than to copy it. If the data that is being created and assigned is immutable then aliasing does not matter as the data won’t change, but there will be a lot of bugs if the data is mutable as it will lead to some issues like see below —

>>> a = 1

>>> id(a)

1904391232

>>> b = a #aliasing a

>>> id(b)

1904391232

>>> b

1

>>> a = 2

>>> id(2)

1904391264

>>> id(b)

1904391232

>>> b

1

>>> a

2

as it can be seen a now points to 2 and id is different as compared to b which is still pointing to 1. In Python, aliasing happens whenever one variable’s value is assigned to another variable, because variables are just names that store references to values.

type() method returns class type of the argument(object) passed as parameter. type() function is mostly used for debugging purposes.

Two different types of arguments can be passed to type() function, single and three argument. If single argument type(obj) is passed, it returns the type of given object.

Syntax :

type(object)

We can find out what class an object belongs to using the built-in type()function:

>>> Blue = [1, 2, 3]

>>> type(Blue)

<class 'list'>

>>> def my_func(x)

... x = 89

>>> type(my_func)

<class 'function'>

Now that we can compare variables to see their type and id’s, we can dive in deeper to understand how mutable and immutable objects work.

Mutable Objects vs. Immutable Objects

Not all Python objects handle changes the same way. Some objects are mutable, meaning they can be altered. Others are immutable; they cannot be changed but rather return new objects when attempting to update. What does this mean when writing Python code?

The following are some mutable objects:

• list
• dict
• set
• bytearray
• user-defined classes (unless specifically made immutable)

The following are some immutable objects:

• int
• float
• decimal
• complex
• bool
• string
• tuple
• range
• frozenset
• bytes

The distinction is rather simple: mutable objects can change, whereas immutable objects cannot. Immutable literally means not mutable.

A standard example are tuple and list: A tuple is filled on creation, and then is frozen – its content cannot change anymore. To a list, one can append elements, set elements and delete elements at any time. Although keep in mind exceptions: tuple is an immutable list whereas frozenset is an immutable set. Quoting stackoverflow answer-Tuples are indeed an ordered collection of objects, but they can contain duplicates and unhashable objects, and have slice functionality frozensets aren’t indexed, but you have the functionality of sets – O(1) element lookups, and functionality such as unions and intersections. They also can’t contain duplicates, like their mutable counterparts.

Let’s create a dictionary with immutable objects for keys —

>>> a = {‘blu’: 42, True: ‘woof’, (‘x’, ‘y’, ‘z’): [‘hello’]}

>>> a.keys()

dict_keys([‘blu’, True, (‘x’, ‘y’, ‘z’)])

As seen above keys in a are immutable, hashable objects, but if you try to call hash() on a mutable object(such as sets), or trying to use a mutable object for a dictionary key, an error will be raised:

>>> spam = {['hello', 'world']: 42}

Traceback (most recent call last): File "<stdin>", line 1, in <module>

TypeError: unhashable type: 'list' >>> d = {'a': 1}

>>> spam = {d: 42}

Traceback (most recent call last): File "<stdin>", line 1, in <module>

TypeError: unhashable type: 'dict'

So, tuples, being immutable objects, can be used as dictionary keys?

>>> spam = {('a', 'b', 'c'): 'hello'}

Traceback (most recent call last): File "<stdin>", line 1, in <module>

TypeError: unhashable type: 'list'

As seen above, if a tuple contains a mutable object, according to the previous explanation about hashability it cannot be hashed. So, immutable objects can be hashable, but this doesn’t necessarily mean they’re alwayshashable. And remember, the hash is derived from the object’s value.

This is an interesting corner case: a tuple (which should be immutable) that contains a mutable list cannot be hashed. This is because the hash of the tuple depends on the tuple’s value, but if that list’s value can change, that means the tuple’s value can change and therefore the hash can change during the tuple’s lifetime.

So far it is now understood that some tuples are hashable — immutable but some other tuple are not hashable — mutable. According to official Python documentation immutable and mutable are defined as — “An object with a fixed value” and “Mutable objects can change their value”. This can possibly mean that mutability is a property of objects, hence it makes sense that some tuples will be mutable while others won’t be.

>>> a = ('dogs', 'cats', [1, 2, 3])

>>> b = ('dogs', 'cats', [1, 2, 3])

>>> a == b

True

>>> a is b

False

>>> a[2].append(99)

>>> a

('dogs', 'cats', [1, 2, 3, 99])

>>> a == b

False

In this example, the tuples a and b have equal (==) values but are different objects, so when list is changed in tuple a the values get changed as a is not longer == b and did not change values of b. This example states that tuples are mutable.

While Python tends towards mutability, there are many use-cases for immutability as well. Here are some straightforward ones:

• Mutable objects are great for efficiently passing around data. Let’s say object anton and berta have access to the same list. anton adds “lemons” to the list, and berta automatically has access to this information.
  If both would use a tuple, anton would have to copy the entries of his shopping-tuple, add the new element, create a new tuple, then send that to berta. Even if both can talk directly, that is a lot of work.
• Immutable objects are great for working with the data. So berta is going to buy all that stuff – she can read everything, make a plan, and does not have to double check for changes. If next week, she needs to buy more stuff for the same shopping-tuple, berta just reuses the old plan. She has the guarantee that anton cannot change anything unnoticed.
  If both would use a list, berta could not plan ahead. She has no guarantee that “lemons” are still on the list when she arrives at the shop. She has no guarantee that next week, she can just repeat what was appropriate last week.

You should generally use mutable objects when having to deal with growing data. For example, when parsing a file, you may append information from each line to a list. Custom objects are usually mutable, buffering data, adjusting to new conditions and so on. In general, whenever something can change, mutable objects are much easier.

Immutable objects are sparingly used in python — usually, it is implicit such as using int or other basic, immutable types. Often, you will be using mutable types as de-facto immutable – many lists are filled at construction and never changed. There is also no immutable dict. You should enforce immutability to optimise algorithms, e.g. to do caching.

Interestingly enough, python’s often-used dict requires keys to be immutable. It is a data structure that cannot work with mutable objects, since it relies on some features being guaranteed for its elements.

Mutable example

>>> my_list = [10, 20, 30]

>>> print(my_list)

[10, 20, 30]

>>> my_list = [10, 20, 30]

>>> my_list[0] = 40

>>> print(my_list)

[40, 20, 30]

Immutable example

>>> tuple_ = (10, 20, 30)

>>> print(tuple_)

[10, 20, 30]

>>> tuple_ = [10, 20, 30]

>>> tuple_[0] = 40

>>> print(tuple_)

Traceback (most recent call last): File "test.py", line 3, in < module > my_yuple[0] = 40

TypeError: 'tuple' object does not support item assignment

If you want to write most efficient code, you should be the knowing difference between mutable and immutable in python. Concatenating string in loops wastes lots of memory , because strings are immutable, concatenating two strings together actually creates a third string which is the combination of the previous two. If you are iterating a lot and building a large string, you will waste a lot of memory creating and throwing away objects. Use list compression join technique.

Python handles mutable and immutable objects differently. Immutable are quicker to access than mutable objects. Also, immutable objects are fundamentally expensive to “change”, because doing so involves creating a copy. Changing mutable objects is cheap.

Interning, integer caching and everything called: NSMALLPOSINTS & NSMALLNEGINTS

Easy things first —

NSMALLNEGINTS is in the range -5 to 0 and NSMALLPOSINTS is in the 0 to 256 range. These are macros defined in Python — earlier versions ranged from -1 to 99, then -5 to 99 and finally -5 to 256. Python keeps an array of integer objects for “all integers between -5 and 256”. When creating an int in that range, it is actually just getting a reference to the existing object in memory.

If x = 42, what happens actually is Python performing a search in the integer block for the value in the range -5 to 256. Once x falls out of the scope of this range, it will be garbage collected (destroyed) and be an entirely different object. The process of creating a new integer object and then destroying it immediately creates a lot of useless calculation cycles, so Python preallocated a range of commonly used integers.

There are exception to immutable objects as stated above by making a tuple “mutable”. As it is known a new object is created each time a variable makes a reference to it, it does happen slightly differently for a few things –

a) Strings without whitespaces and less than 20 characters
b) Integers between -5 to 256 (including both as explained above)
c) empty immutable objects (tuples)

These objects are always reused or interned. This is due memory optimization in Python implementation. The rationale behind doing this is as follows:

1. Since programmers use these objects frequently, interning existing objects saves memory.
2. Since immutable objects like tuples and strings cannot be modified, there is no risk in interning the same object.

So what does it mean by “interning”?

interning allows two variables to refer to the same string object. Python automatically does this, although the exact rules remain fuzzy. One can also forcibly intern strings by calling the intern()function. Guillo’s articleprovides an in-depth look into string interning.

Example of string interning with more than 20 characters or whitespace will be new objects:

>>> a = "Howdy! How are you?"

>>> b = "Howdy! How are you?"

>>> a is b

False

but, if a string is less than 20 char and no whitespace it will look somewhat like this:

>>> a = "python"

>>> b = "python"

>>> a is b

True

As a and b refer to the same objects.

Let’s move on to integers now.

As explained above in macro definition integer caching is happening because of preload python definition of commonly used integers. Hence, variables referring to an integer within the range would be pointing to the same object that already exists in memory:

>>> a = 256

>>> b = 256

>>> a is b

True

This is not the case if the object referred to is outside the range:

>>> a = 1024

>>> b = 1024

>>> a is b

False

Lastly, let’s talk about empty immutable objects:

>>> a = ()

>>> b = ()

>>> a is b

True

Here a and b refer to the same object in memory as it is an empty tuple, but this changes if the tuple is not empty.

>>> a = (1, 2)

>>> b = (1, 2)

>>> a == b

True

>>> a is b

False

Passing mutable and immutable objects into functions:

Immutable and mutable objects or variables are handled differently while working with function arguments. In the following diagram, variables a, band name point to their memory locations where the actual value of the object is stored.

Major Concepts of Function Argument Passing in Python

Arguments are always passed to functions by object in Python. The caller and the function code blocks share the same object or variable. When we change the value of a function argument inside the function code block scope, the value of that variable also changes inside the caller code block scope regardless of the name of the argument or variable. This concept behaves differently for both mutable and immutable arguments in Python.

In Python, integer, float, string and tuple are immutable objects. list, dict and set fall in the mutable object category. This means the value of integer, float, string or tuple is not changed in the calling block if their value is changed inside the function or method block but the value of list, dict or set object is changed.

Python Immutable Function Arguments

Python immutable objects, such as numbers, tuple and strings, are also passed by reference like mutable objects, such as list, set and dict. Due to state of immutable (unchangeable) objects if an integer or string value is changed inside the function block then it much behaves like an object copying. A local new duplicate copy of the caller object inside the function block scope is created and manipulated. The caller object will remain unchanged. Therefore, caller block will not notice any changes made inside the function block scope to the immutable object. Let’s take a look at the following example.

Python Immutable Function Argument — Example and Explanation

def foo1(a):

# function block

a += 1

print(‘id of a:’, id(a)) # id of y and a are same

return a

# main or caller block

x = 10

y = foo1(x)

# value of x is unchanged

print(‘x:’, x)

# value of y is the return value of the function foo1

# after adding 1 to argument ‘a’ which is actual variable ‘x’

print(‘y:’, y)

print(‘id of x:’, id(x)) # id of x

print(‘id of y:’, id(y)) # id of y, different from x

Result:

id of a: 1456621360

x: 10

y: 11

id of x: 1456621344

id of y: 1456621360

Naomi Clark’s introduction of tabletop game developer Avery Alder, for her Practice 2018 talk, was an effusion for her trade: “We see non-digital design as a great way to prototype and jam quickly, but there are also things you can do in a non-digital space that digital games have only just begun to catch up to,” she said, describing various communal and interpersonal dimensions of tabletop play, “like the collaboration between gamemasters and  emergent and collaborative storytelling that happens in these spaces.”

Alder, who is perhaps best known for the game Monsterhearts, spoke about her latest game, Dream Askew, through the lens of her past work including Monsterhearts, a paranormal romance game about messy teenage life; The Quiet Year, a conversational game about a post-apocalyptic community dealing with a good year after defeating a major threat; and Brave Sparrow, a solo LARP meant to be played amidst your daily life. The latter is a “pervasive game,” which asks the player to imagine they’re a sparrow, “to help you develop grace, and a sense of self.”

Wrapping up this development CV, she sums up the core themes of her work as “queerness, the apocalypse, relationships, self-doubt, and self-discovery.” All of these are combined in her latest game, a post-apocalyptic RPG entitled Dream Askew. 

Alder, who understood herself to be performing something of a didactic role for an audience that was less familiar with indie tabletop, sought first to situate her new game in the larger, recent history of tabletop. She identified five design trends in tabletop roleplaying games from the aughts: scene-based conflict resolution, pre-negotiated stakes, everything was made a trait, bespoke dice mechanics, and endgame mechanics. 

“Apocalypse World positioned the act of roleplaying as a conversation; we’re talking about what we’re doing to advance the story,” she said, arguing that Apocalypse World fundamentally responded to all these trends. Where mechanics were often constant and agnostic or orthogonal to the evolving story, Apocalypse World flipped that on its head, by Alder’s lights. Conversational story progressed the plot, and the mechanics were invoked by the story in a way that always produced clear story outcomes. 

Situational moves and partial success were always deeply tethered to the unique circumstances of everyone’s character and story. Moves facilitated more conversation and collective storytelling, by compelling hard choices and exacting costs. Alder was quick to note that some gamemasters had always played games this way, but for many others it was a “revelation” to enthrone story and really emphasize the RP in RPG. 

Ever the minimalist, with an eye to access, Alder critiqued her beloved Apocalypse World, however. Despite its pared-down, non-crunchy modality, the game still comes across as jargony and unduly complex. For veteran roleplayers, it may be intuitive. But for neophytes, it may still be unduly intimidating. The “arcane presentation” and “participation demands” imposed limits on people with only two hours to play. 

More and more, she wanted to create an accessible game that could be picked up and enjoyed by someone who’d never played an RPG before–digital or analog.

“Acronyms are the number one way to convince new players that they can’t do what you’re trying to get them to do,” she said, and while this got a laugh, she was only half joking.

The lessons she took from this, with her own Powered by the Apocalypse games, were to reduce the appearance of complexity, eliminate jargon, and the alter appearance of math. Even Apocalypse World’s simple 2d6 was removed in favor of a simpler token-exchange economy. But this wasn’t merely a process of taking things away: it was also about adding more emphasis on relationships, which Apocalypse World already did well, “but I was greedy and wanted more,” Alder joked.

She then pivoted to discussing the origin of a mod for Dream Askew, set in a shtetl in the 19th Century Russian Pale of Settlement, created by Benjamin Rosenbaum with Alder’s blessing. It was called Dream Apart. As the two discussed the development of the game, it helped her better critique her own game, refining mechanics and making them more elegant. One innovation, developed by Rosenbaum, cut back on logistics in Dream Askew. Instead of having mutually exclusive playbooks (for their character class and a larger setting element), a mechanic was developed to allow players to swap mid-play.

She also noted that her own work failed to live up to her own goals. Some command language like ‘explore themes of compulsion and estrangement,’ in a list of thematic recommendations for a particular class, were too vague and cerebral, according to feedback. “I might as well have told people ‘make deep and meaningful art,’” she said. Paring these down to brief, punchy ‘tips’ as opposed to ‘principles,’ helped her realize her goals.

Dream Askew and Dream Apart are now being Kickstarted and sold together. Alder noted the many similarities between the games, each, for instance, dealing with the theme of hope amidst hardship in a marginalized community. Alder also noted where the games were different. Rosenbaum’s has an extensive glossary of Jewish terminology to help situate the player in the distinct historical setting, while Alder eschewed that in service to her understanding of queerness, which is “elusive to definition.” The queer relationships found in her games are meant to be contingent and polyvocal, after all.

Alder and Rosenbaum played off both each other and off of larger works like Apocalypse World, which in turn was a reaction to even larger design trends in the tabletop world. This sort of relational design creates complex, even beautiful lineages of design, and as Alder put up a slide with art from Askew, Apart, and Apocalypse World on screen, it seemed to emphasize this fact. “Dream Askew took the child role to the parent of Apocalypse World,” she said, driving the metaphor home. “Benjamin’s coming up with cool ideas, I want to let them change and challenge my vision,” she said, describing the emerging collaboration between her and Rosenbaum.

In the Q&A, she talked a bit about a subtle but profoundly important issue: “learning to trust people,” she said, “has been really rewarding.” In this case, that meant letting people mod her games without asking for royalties, which, she said “wasn’t profitable anyway.” She felt “gross” asking other, mostly queer developers for money for the right to modify her game which was, itself, heavily inspired by Apocalypse World. She spoke movingly of feeling rewarded by giving it away, and meeting those developers later at conventions; they’d buy her coffee and update her on their progress. 

This, she said, felt much better to her and led to considerably more growth for everyone involved. As she put it when discussing design challenges in response to another question, there was a process of “radiating outward to meet the wilderness.”

Alder had a clear design goal–make a game anyone can pick up–and pursued it aggressively, whittling away the often lovable but impenetrable garnish of tabletop roleplaying. In the process, it served to surface the core of all tabletop roleplaying: the relationships between players, and between their characters. In the process, there was a lot to learn about trust between developers, and reaching out with an open hand. Sharing one’s work can be frightening, but, as was also made clear in Adriel Wallick’s talk, it’s a necessary step in one’s growth as a developer. What Alder added was simply this: if your work is to flourish, then even your sense of ownership might have to give way.