MassLight invests capital and engineers, in exchange for equity.

MassLight

It smells because there are likely many instances where it could be edited or improved. Most of these smells are just hints of something that might be wrong. Therefore, they are not required to be fixed per se… (You should look into it, though.) Previous Code Smells You can find all the previous code smells (Part i - XXXII) . here Let's continue... Code Smell 161 - Abstract/Final/Undefined Classes Your classes are abstract, final, or undefined TL;DR: If your language has the right tool, your classes should be either abstract or final. Problems Subclassification for Code Reuse Classes with concrete subclass just one Liskov Substitution Violation Problem Yo-Yo Solutions Declare all your leaf classes as and the rest of them as . final abstract Context Managing hierarchies and composition is the main task of a good software designer. Keeping hierarchies healthy is crucial to favor cohesion and avoid . coupling Sample Code Wrong public class Vehicle
{
  // the class is not a leaf. Therefore it should be abstract
    
  // an abstract method that only declares, but does not define the start 
  // functionality because each vehicle uses a different starting mechanism
  abstract void start();
}

public class Car extends Vehicle
{
  // the class is a leaf. Therefore it should be final
}

public class Motorcycle extends Vehicle
{
  // the class is a leaf. Therefore it should be final
} Right abstract public class Vehicle
{
  // the class is not a leaf. Therefore it must be abstract  
 
  //an abstract method that only declares, but does not define the start 
  //functionality because each vehicle uses a different starting mechanism
  abstract void start();
}

final public class Car extends Vehicle
{
  // the class is a leaf. Therefore it is final
}

final public class Motorcycle extends Vehicle
{
  // the class is a leaf. Therefore it is final
} Detection Automatic [x] Since this is enforced by static analysis, we can't do it with most available tools. Tags Subclassification Conclusion We should look back at our classes, and start qualifying them either as abstract or final. There are no valid cases for two concrete classes, one subclassifying the other. Relations Code Smell 11 - Subclassification for Code Reuse Code Smell 136 - Classes With just One Subclass Code Smell 37 - Protected Attributes Code Smell 58 - Yo-yo Problem More Info Coupling - The one and only software design problem Deep Subclasses Disclaimer Code Smells are just my . opinion Credits Photo by on William Bossen Unsplash When the final design seems too simple for the amount of work you've put in, then you know you're done. Brady Clark Code Smell 162 - Too Many Parentheses Parentheses are free of charge. Aren't they? TL;DR: Use as few parentheses as possible. Problems Readability Syntactic complexity Solutions Remove all not necessary parentheses Context We read code from left to right (at least, in western culture). Parentheses often break this flow, adding cognitive complexity. Sample Code Wrong schwarzschild = ((((2 * GRAVITATION_CONSTANT)) * mass) / ((LIGHT_SPEED ** 2))) Right schwarzschild = (2 * GRAVITATION_CONSTANT * mass) / (LIGHT_SPEED ** 2) Detection Automatic [x] This is a fully automated code smell. It is based on syntax trees. Many tools detect it. Exceptions On some complex formulas, we can add extra parenthesis for terms’ readability. Tags Readability Bloaters Relations Code Smell 02 - Constants and Magic Numbers Conclusion We write code once and read it too many times. Readability is king. Credits Photo by on Nick Fewings Unsplash If someone claims to have the perfect programming language, he is either a fool or a salesman or both. Bjarne Stroustrup Code Smell 163 - Collection in Name Have you ever seen a CustomerCollection? TL;DR: Don't use 'collection' in your name. It is too abstract for concrete concepts. Problems Readability Abstraction Abuse Bad Naming Solutions Rename the collection with a specific name. Context Naming is very important. We need to deal a lot with collections. Collections are amazing since they don't need nulls to model the absence. An empty collection is polymorphic with a full collection. We avoid and . nulls IFs We often use bad and vague names instead of looking for good names in the . MAPPER Sample Code Wrong for (var customer in customerCollection) {

    // iterate with current customer

}



for (var currentCustomer in customersCollection) {

    // iterate with current customer

} Right for (var customer in customers) {

    // iterate with current customer

} Detection Semi-Automatic [x] All linters can detect a bad naming like this. It can also lead to false positives, so we must be cautious. Tags Naming Conclusion We need to care for all our clean code, variables, classes, and functions. Accurate names are essential to understand our code. Relations Code Smell 134 - Specialized Business Collections More Info What exactly is a name - Part II Rehab Credits Photo by on Mick Haupt Unsplash Alzheimer's Law of Programming: Looking at code you wrote more than two weeks ago is like looking at code you are seeing for the first time. Dan Hurvitz Code Smell 164 - Mixed Indentations Tabs vs Spaces. The most significant computer problem. TL;DR: Don't mix indentation styles Problems Readability Code consistency Standards violation Solutions Choose one of them. Stick to it. Enforce it with code standards tests. Share the rules on all the codebases. Use an IDE like VSCode or WebStorm that doesn't include tabs at all. Context Whenever I publish an article many people don't care about the sample intent and rush to point out indentation mistakes. Choosing one standard over the other will be a great solution. Spaces always count as one. Tabs can count as many different options. Sample Code Wrong function add(x, y) {

// --->..return x + y;



      return x + y;

}



function main() {

// --->var x = 5,

// --->....y = 7;



    var x = 5,

        y = 7;

} Right function add(x, y) {

// --->return x + y;

    return x + y;

} Detection Automatic [x] Any parser can enforce this rule. Exceptions Some languages like Python consider indent as part of the syntax. In these languages, indentation is not accidental since it changes code semantics. Tags Code Standards Conclusion There's been so much debate on this subject. The smell is related to mixing them, not about using one instead of another. Some IDEs automatically convert one convention to the other one. Relations Code Smell 48 - Code Without Standards More Info ES Lint Whatever the device you use for getting your information out, it should be the same information. Tim Berners-Lee Code Smell 165 - Empty Exception Blocks On Error resume next was the first thing I learned in my first job. TL;DR: Don't avoid exceptions. Handle Them. Problems Principle Violation Fail Fast Solutions Catch the exception, and deal with it explicitly. Context In the early programming days, we privileged the systems running before error handling. We have evolved. Sample Code Wrong # bad

import logging



def send_email(): 

  print("Sending email") 

  raise ConnectionError("Oops")

  

try:

  send_email() 

except: 

  # AVOID THIS

pass Right import logging



logger logging.getLogger(__name___)

try:

  send_email()

except ConnectionError as exc:

  logger.error(f"Cannot send email {exc}") Detection Automatic [x] Many linters warn us on empty exception blocks Exceptions If we need to skip and ignore the exception, we should document it explicitly. Tags Exceptions Conclusion Prepare to deal with the errors. Even if you decide to do nothing, you should be explicit with this decision. Relations Code Smell 132 - Exception Try Too Broad More Info Fail Fast On Error Resume Next Package Credits Photo by on James Best Unsplash Thank you @ Jan Giacomelli Twitter Optimization hinders evolution. Everything should be built top-down, except the first time. Simplicity does not precede complexity, but follows it. Alan Perlis Software Engineering Great Quotes 5 more code smells are coming soon…

How to Find the Stinky Parts of Your Code [Part XXXIII]

In previous episodes, we showed some heuristics to find not so good code. Code Smells Part I Part II Part III Part IV Part V Part VI Part VII Part VIII Part IX Part X Part XI Part XII Part XIII Part XIV Part XV Part XVI Part XVII Part XVIII Part XIX Part XX Let’s fixed them! Refactoring 001 - Remove Setters Setters violate immutability and add accidental coupling TL;DR: Make your attributes private to favor mutability Problems Addressed Mutability setXXX() violates good naming policies since it does not exist on the MAPPER Accidental coupling Related Code Smells Code Smell 28 - Setters Code Smell 01 - Anemic Models Steps Locate the setters' usage If you are setting essential properties move them to the constructor and remove the method If you need to change an accidental property it is not a setter. Remove the setXXX prefix Sample Code Before public class Point {
   protected int x;
   protected int y;
  
   public Point() {
        this.x = 0;
        this.y = 0;        
   }
    
   public void setX(int x) {
	this.x = x;
   }
  
   public void setY(int y) {
        this.y = y;
  } 
}

Point location = new Point();
//At this momment, it is not clear which points represent
//It is coupled to constructor decision.
//Might be null or some other convention

location.setX(1);
//Now we have point(1,0)

location.setY(2);
//Now we have point(1,2) public class Car {
   protected int speed;
  
   public Car() {     
   }
    
   public void setSpeed(Speed desiredSpeed) {
	this.speed = desiredSpeed;
   }   
}

Car tesla = new Car();
//We have no speed??

tesla.setSpeed(100 km/h);
//Now our car runs fast After //1. We locate setters usage
location.setX(1);

location.setY(2);

//2. If you are setting essential properties move 
//them to the constructor and remove the method
public class Point {
   public Point(int x, int y) {
        this.x = x;
        this.y = y;        
     //We remove the setters
   }

Point location = new Point(1, 2); public class Car {
   protected int speed;
  
   public Car() {    
     this.speed = 0 km/h;
   }
    
   public void speed(Speed desiredSpeed) {
	    this.speed = desiredSpeed;
   }   
}


//1. Locate the setters' usage
//3. If you need to change an accidental property
// it is not a setter. Remove the setXXX prefix


Car tesla = new Car();
//Our car is stopped

tesla.speed(100 km/h);
//We tell the desired speed. We don't set anything
//We don't care if the car stores its new speed.
//if it manages through the engine
//if the road is moving etc Type Semi-Automatic [x] We should detect setters (unless they use meta-programming) with our IDEs. We can also remove them and see which tests fail if we have good coverage Tags Mutability Related Refactorings Remove Getters Pass essential properties in the constructor Initialize essential properties in the constructor Credits Image by on Comfreak Pixabay Refactoring 002 - Extract Method Find some code snippets that can be grouped and called atomically. TL;DR: Group your cohesive sentences together Problems Addressed Readability Complexity Code Reuse Related Code Smells Code Smell 03 - Functions Are Too Long Code Smell 05 - Comment Abusers Code Smell 18 - Static Functions Code Smell 22 - Helpers Code Smell 74 - Empty Lines Code Smell 78 - Callback Hell Code Smell 102 - Arrow Code Steps Move the code fragment to a separate new method Replace the old code with a call to the recently created method. Sample Code Before object Ingenuity {
    fun moveFollowingPerseverance() {
        // take Off
        raiseTo(10 feet)
      
        // move forward to perseverance
        while (distanceToPerseverance() < 5 feet) {
             moveForward()             
         }
        
        // land
        raiseTo(0 feet)
    } After object Ingenuity {   
    //1. Move the code fragment to a separate new method 
    private fun takeOff() {
        raiseTo(10 feet)
    }
    
    //1. Move the code fragment to a separate new method 
    private fun moveForwardToPerseverance() {
       while (distanceToPerseverance() < 5 feet) {
             moveForward()             
         }
    }
    
    //1. Move the code fragment to a separate new method 
    private fun land() {
        raiseTo(0 feet)
    }
    
    fun moveFollowingPerseverance() {
        takeOff()
        //2. Replace the old code with a call to the recently created method.
        moveForwardToPerseverance()
        //2. Replace the old code with a call to the recently created method.
        land()
        //2. Replace the old code with a call to the recently created method.
    }
} Type Automatic [x] Many IDEs support this safe refactoring Why code is better? Code is more compact and easier to read. Functions can be reused. Algorithms and functions are more declarative hiding implementative details on extracted code. Limitations Does not work well if you use . meta-programming anti-pattern Tags Complexity Readability Related Refactorings Move method to a new class Credits Image by on Hreisho Pixabay Refactoring 003 - Extract Constant You need to use some values explaining their meaning and origin TL;DR: Name all your magic numbers Problems Addressed Readability Complexity Code Reuse Related Code Smells Code Smell 02 - Constants and Magic Numbers Steps Move the constant code fragment to a constant declaration Replace the values with a reference to the constant. Sample Code Before double energy(double mass) {
  return mass * 300.000 ^ 2;
} After //1. Move the constant code fragment to a constant declaration
final double LIGHT_SPEED = 300.000;

double energy(double mass) {
  //2. Replace the old code with a reference to the constant.
  return mass * LIGHT_SPEED ^ 2;
} Type Automatic [x] Many IDEs support this safe refactoring Why code is better? Constant names add meaning to our code. Magic numbers are difficult to understand and change. Code must be as declarative as possible. Tags Readability Related Refactorings Refactoring 002 - Extract Method Credits Image by on Tumisu Pixabay Refactoring 004 - Remove Unhandled Exceptions Creating YAGNI exception classes pollutes our environment. Let's remove them. TL;DR: Remove unnecessary and not references empty exception classes. Problems Addressed Empty Classes Namespace Polluted Related Code Smells Code Smell 26 - Exceptions Polluting Steps Check there are no references to the empty exception class. Replace the throw sentence with a generic one. Sample Code Before class RangeNotSatisfiedException < StandardError
end

begin
    raise RangeNotSatisfiedException.new "Range must be betweet 0 and 10"
rescue RangeNotSatisfiedException => e
    puts e.message 
    puts e.exception_type 
end After # 1. Check there are no references to the empty exception class.

# 2. Replace the throw sentence with a generic one.

begin
    raise StandardError.new "Range must be betweet 0 and 10"
rescue StandardError => exception
    puts exception.message 
    puts exception.exception_type 
end Type Automatic [x] If the Exception class has no references we can perform a Safe Remove and replace it with class. Exception Why the code is better? We remove an empty class nobody uses. We shrink the code Limitations If we need to declare an empty exception class as documentation for an API module, our clients might need to catch it. This is a and example. gold plating YAGNI Tags Clean up Related Refactorings Safe Remove Credits Image by on danielkirsch Pixabay Refactoring 005 - Replace Comment with Function Name Comments should add value. And function names too. TL;DR: Don't comment on what you are doing. Name what you are doing. Problems Addressed Bad Names Comments Related Code Smells Code Smell 05 - Comment Abusers Code Smell 75 - Comments Inside a Method Code Smell 06 - Too Clever Programmer Steps Name the function with the previous comment Remove the Comment Sample Code Before <?

function repl($str) {
  // Replaces with spaces the braces 
 
  $str = str_replace(array("\{","\}")," ",$str);
  return $str;

} After <?

// 1. Name the function with the previous comment
// 2. Remove the Comment

function replaceBracesWithSpaces($input) {
  
  return str_replace(array("\{","\}")," ", $input);

} Type Semi-Automatic [x] Some IDEs have this refactoring although naming is not fully automatic. Why the code is better? Comments always lie. It is hard to maintain comments. On the contrary, Functions are alive and self-explanatory. Limitations As always, very important design decisions are valid comments. Tags Comments See also What is in a name? Credits Image by on Jannik Texler Pixabay This article is part of the Refactoring Series. More smells and more refactorings are on the way!

Improving the Code One Line at a Time

The fact that airlines function at all is incredible for those who know how they work. Airlines are hubs of communication in a way, as they are involved with maintenance, security, reservation details, baggage, flight delays, passenger logistics, and cancellations. They track baggage, travel arrangements, as well as passenger loyalty points. Distributors and tourist agencies, for instance, need to track airline details, too, and if information goes afoul, travelers and airlines can lose hundreds to millions of dollars, at best. At worst, cracks in data protection can lead to a disaster. Luckily, blockchain technology (with its transparent ledger and smart contracts) shows potential in helping each of these different layers of communication know exactly what’s going on moment to moment. It can collaboratively update important information, keep airline and passenger data secure, contract ticket conditions for smooth flow, and refund money if any of the conditions are broken. The Problems Airlines have several problems, foremost of which is that there is no single source of truth about flight data, and the data that does exist is not easily accessible by all parties. This is known as the “flight data problem.” While there are many cases of airlines and airports collaborating to share flight data, this data still resides in separate silos. The result is that when there are flight delays, passenger apps, airport flight information display systems, airline websites, their telephone reservation systems and agents give contradictory information. This may result in a loss to the airline’s reputation, the loss of time and money for that airline, travellers, and stakeholders, and it can result in costly litigations. USA Today, for instance, the database website masFlight.com and highlighted that cancelled flights cost airlines, stranded passengers, and corporate companies millions of dollars. cited The existence of fractured, centralized information also leads to other problems, like websites shutting down or becoming hacked, airlines unable to track their maintenance needs, and the struggle to track passengers and baggage. That’s where the blockchain comes in with its developing technology that’s slanted to help airlines improve customer experience and safety. Blockchain solutions: For the airline With 3.8 billion air travelers in 2016, as well as air travel projected to double over the next 19 years, the airline industry has its work cut out for them. They need to provide maximum security and safety, show responsiveness and care, display efficacy, and communicate with their stakeholders and travelers in a timely manner. according to the International Air Transport Association (IATA), And it’s with the following areas where the blockchain is about to take off: Ticketing — Most airlines provide the option of e-tickets in order to smooth over the passenger’s flight. E-tickets are, in essence, the customer’s travel details that are stored in and retrieved from a massive database. The blockchain can use smart contracts to add business logic and terms and conditions around how that ticket is sold and used, which can help the tickets be sold by different partners, and in real time from anywhere in the world. Passenger information — The amount of data shared in real time is enormous. Forget about coordinating flights. Even when tracking passengers on a single flight, each airline has to, at the bare minimum, keep track of when a passenger has checked in for their flights, when their tickets are scanned as they board, and where their bags are in reference to their final destination. Airlines do not want another PR disaster like where a man was forcefully dragged from an overbooked United flight in Chicago. Once the decentralized ledger achieves the same data speed as centralized websites, the blockchain can use its unique qualities of transparency and collaborativeness to prevent overbooking and revenue loss. United’s Dr. Dao incident, Cancelled or delayed flights — Airlines have to notify passengers of scheduled changes at least 14 days before they occur, otherwise passengers receive compensation or a refund. Recently, for flight delays. Understandably, the airlines were none too pleased, but , aside from which flight data resides in different silos (folders, categories, different IT processes or systems) so travelers tend to receive contradictory information. In time, the blockchain could present this single point of truth, with stakeholders providing up-to-date and verified information that saves airlines both money and stress. India proposed higher compensation they are not always able to know or prevent changes in time Maintenance — In 2017, the blockchain as a digital ledger shared by airlines, MRO teams, and OEMs to record flight events, operation conditions, and scheduled aircraft maintenance checks. Airlines have to ensure that all data about the status of an engine or other parts are up to date and securely shared by all interested parties. At the moment, airline maintenance logs are in cumbersome databases or, at worst, in paper binders. The blockchain can collate all of that information and verify that all parts are legitimate, while offering a real-time record of repairs, purchases, construction, and maintenance checks. This visibility can take aircraft security to whole new levels. IBM proposed Security and identity — Airlines have the crucial responsibility of protecting passenger records, flight manifests, and crew information. In May 2018, the digital security company and found that only six scored a perfect ranking. Most airlines, including Delta Airlines and Southwest Airlines, achieved an average rating. Data protection in today’s insecure world cannot be understated. Blockchain technology with its high resilience to hacking can provide a far less risky method of storing and sharing information through the use of authorized access requirements. Dashlane tested the password of 55 airline websites Resilience to hacking and glitches — Because airline industries are centralized, they are vulnerable to hacking, crashing, or computer outage. F . In 2016, more than 650 flights and delaying many more in the US, Japan, Italy, and the UK. With a decentralized blockchain, however, airlines, travelers, and stakeholders can rely on an uninterrupted flow of credible, up-to-date information. or a full five days in 2015, Russia crashed Sweden’s air traffic control system to allegedly test electronic warfare capabilities Delta experienced a computer outage, cancelling Blockchain solutions: For the traveler Airline travelers can find that the blockchain has solutions for them, too, for the following reasons: , offered by frequent flyer programs, save you money on air travel, or they could offer you other rewards. Usually, you have to wait until loyalty points settle in order to use them, and you are limited on where you can spend them. By tokenizing loyalty points on the blockchain, you can get instant value by redeeming them on the spot. Loyalty — Loyalty points — Airlines tag all sorts of fees on top of their already high expenses. Given meager competition, certain companies have a monopoly on the industry and set their own fees. On top of that, airlines charge fees and taxes for the airport, distributors, local, state, and federal governments. Blockchain technology short-circuits some of these fees by bringing other players into the field and eliminating third-party intervention. Cost Since data resides on different silos, passengers tend to get conflicting information on their flights. In 2017, which investigated the potential use of the blockchain for flight information storage and management. It found that since the blockchain presents a single source of truth for flight data, it can save passengers considerable time, stress, and money. The flight data problem — IT firm SITA announced the results of its FlightChain project, In short, blockchain technology can revolutionize the airline industry in four major ways: It provides access to cryptographically fixed updates/information that is distributed to all participants in the network, so everyone knows that the record of transactions (i.e., the details of flight change or cancellation) is true and consistent for all participants. The blockchain provides a mechanism for several people to update a common data set, where that data set is visible to all participants on that ledger (primarily all stakeholders of that particular airline). With centralized systems, you don’t know what to believe aside from what the system could crash or be hacked. The blockchain has the trust aspect since all records are immutably recorded and collaboratively shared, so all participants see them and can contradict them if necessary. A centralized database is controlled only by one authority, which opens it up to mistakes. The ledger, however, works through smart contracts where not only do different organizations share control of the data, but they also implement an approved and shared set of business rules through smart contracts. This gives the data credibility, since it makes errors far less likely to occur. Blockchain Services for Airlines The three blockchain platforms for airlines are , and . Further Network, Fizzy Winding Tree Further Network Further Network is launching a decentralized billing, settlement, and payment (BSP) model for safer and more convenient traveling, as well as other options to meet all travel needs. It achieves these developments through its smart contracts (called Smart Travel Records [STR]) and its digital currency, Aton. Further’s innovations help airline industries improve their services, visibility, and profitability. Airline are barely able to function, let alone innovate, with their 2.5%-5% profit margins. A decentralized BSP model hacks settlement and payment costs, enabling airlines to increase their profits. Further accomplishes this by removing third parties and by accomplishing uninterrupted, real-time P2P communication. Further offers airlines and travelers the following: 1. The decentralized billing, settlement, payment (BSP) process: Further Network helps airlines reduce operational costs (by eliminating third parties), so airlines can focus on customer-centric experiences, consequently increasing their profits. 2. Passenger wallet with biometric ID: Further gives users an Individual Customer Wallet for managing their travel assets and Aton transactions. Also adds the biometric identification to their wallets to help improve the “customer’s journey” by reducing the multiple ID data points into a single point that is under control of the traveler. 3. P2P Travel Product Distribution: Since the International Air Transport Association (IATA) serves as a liaison between airlines and travel agencies, non-IATA airlines lack visibility. Further’s blockchain not only helps such airlines promote themselves, but they also help these companies transmit their inventory over the distributed ledger. 4. The blockchain-based passenger service system: Further’s blockchain gives airlines a secure decentralized data management system. The ticket must do more than just record flight information. It should also be customizable for the travelers’ needs and preferences. Tokenizing these tickets (through STR) help stakeholders and travelers change, sell, add options, and customize their tickets. 5. Open network standards and P2P exchange market: Airlines, hotels, car rentals, cruise and railroad operators, and stakeholders alike could use Further Network’s blockchain to build their own technology, helping them expand and innovate their systems. In short, Further’s blockchain technology helps airlines improve all components of their business including customer service, inventory management, transportation, torage and materials handling, marketing, information processing, demand forecasting, and other activities. Blockchain technology also helps airlines boost their direct channel sales, cross-selling, and dynamic pricing. The shared ledger provides a closed decentralized cloud system for secure data management and cost cutting. With all stakeholders sharing real-time communication through Further’s ledger, airlines can prevent security problems, boost their appeal, and increase their profits. s Fizzy Fizzy, rolled out by French insurance company AXA, is another blockchain platform that promises customers instant and conflict-free refunds on airline delays longer than two hours. Airline passengers subscribe to Fizzy and enter their ticket numbers on Fizzy’s shared ledger. Fizzy’s smart contracts record traveler details and the condition that whenever an airline has at least a two hour delay, payment is automatically triggered and the traveler receives compensation. Fizzy’s smart contracts are connected to global air traffic databases, so passenger compensation is automatic. Customers do not need to file claims and the smart contract minimizes discrepancies between the insurance company and customers. For now, payouts are issued in fiat currencies, although AXA aims to eventually use Ether. Fizzy, too, only covers US transatlantic flights and Charles de Gaulle Airport in Paris. By the end of 2018, it plans to cover the rest of the world. Winding Tree Winding Tree uses the Ethereum network as a decentralized travel platform that minimizes transaction costs between suppliers and end users, including hotels. Winding Tree levels the field by allowing travelers unmediated interactions with all distributors, not just those who monopolize the industry, so that travelers can get the lowest costs. Since the blockchain is transparent, participants can also follow what’s going on. The platform uses an ERC20 token, Lif. Other benefits include the following: Suppliers distribute inventory directly to points of sale, skipping costly intermediaries and bottlenecks. Sellers access inventory from all suppliers from a single platform with no markup fees and no barriers to entry. Travelers use Lif to directly pay for travel needs. The result? Air travel and airline operations becomes cheaper, smoother, and more reliable for all parties and the airline industry becomes more democratic. , are three of many airlines that use Winding Tree. Air New Zealand Swiss Air, and Lufthansa Conclusion Blockchain technology for the airline industry is a perfect match. Multiple actors depend on timely, coherent, consistent, and thoroughly accurate data for not only making and implementing plans but also for sharing traveler and operation information, among other aspects. At the moment, airlines have a problem with communication discrepancy resulting in impaired airline reputation, costly litigations, and the loss of time and money for the airline, travellers, and stakeholders. The blockchain technology can help solve this problem with its transparent, distributed ledger that is both permanent and secure. Airlines can use blockchain technology to manage their massive amounts of data on flights, baggage, passengers, and weather. They can use it to track maintenance needs and to improve ticketing services by using smart contracts. Passengers can use the blockchain for managing loyalty points, for coordinating their flights, and for cutting costs, among other things. Both airlines and travelers can use blockchain services like Further Network, Fizzy, or Winding Tree to integrate airline touchpoints, get refunds, and minimize transaction costs. By adopting blockchain technology, airlines can create more efficient service models and provide better customer service and security. About the author: — Founder of Geekforge.io and Howtotoken.com. Interviewing the top 10,000 worldwide experts who reveal the biggest issues on the way to technological singularity. Join my . Kirill Shilov #10kqachallenge: GeekForge Formula

Could crypto technology make the future of airlines better?

Before we start I would like to preface this by saying this is an article about the programmatic side of dark mode. For design-cetric information, see this super useful and detailed article by → @abhirajb https://hackernoon.com/how-to-implement-dark-mode-5-essential-tips-to-remember Technologies Used HTML CSS Vanilla JS (localStorage) Righty-ho, let’s start. So you wanna add darkmode to your website because that’s what all the cool kids are doing. I was in the same position, then I did a bit of googling and now I’m the master so sit down, open your editor and listen to my words. We want four things. To know what the clients system preference for dark mode. To know what the clients website preference for dark mode. To listen to whether the clients system preference has changed. To listen to whether the website preference has changed. The HTML… Here is my wicked cool website. I created an index.html in the root of an empty directory. <!DOCTYPE html>
<html>
    <head lang="en">
        <meta charset="utf-8">
        <title>DARKMODE - Rules</title>
        <script src="darkmode.js"></script>
    </head>
    <body>
        <h1>My awesome website</h1>
        <p>This website is a website.</p>

        
        <button id="darkmode-button">Darkmode</button>
    </body>
</html> As you can see, there is a button element. We will use this to toggle dark mode on or off. There is also a link to two external resources, a javascript file to hold the logic for darkmode and css where the style rules for darkmode live. This is what it looks like now, without dark mode enabled The Javascript Now is time to build the logic for determining when darkmode is applied. Let’s write a little logic table to make sure our code follows a sensible set of rules. I want the website preference to take precedence over the system preference when toggled and the system preference to take precedence over the website preference when that is toggled. But you can choose your own logic, this just makes sense in my warped brain. It also offers a nice recipe to write code from. Logic ID Users Operating System Default Website preference Darkmode Outcome 1 Light Light or None Light 2 Light Dark Dark 3 Dark Dark or None Dark 4 Dark Light Light 5 Light Light (Toggled) Light 6 Light Dark (Toggled) Dark 7 Dark Dark (Toggled) Dark 8 Dark Light (Toggled) Light 9 Light (Toggled) Light Light 10 Light (Toggled) Dark Light 11 Dark (Toggled) Dark Dark 12 Dark (Toggled) Light Dark Now, open up and start typing… darkmode.js Making sure my uber complex site has loaded first… // This checks to make sure the DOM has loaded properly before we start messing with it
document.addEventListener('DOMContentLoaded', function(event) {

  // DM logic in here...

} The rest of the code will be inside this event listener. Selecting the toggle button and body elements… // Select the body element
let body = document.querySelector('body')

// Select the dark mode button
let darkMode = document.querySelector('#darkmode-button'); It will allow us to test if the dark mode button has been clicked and attach a class to the body element. Setting up helper functions… These will make the page dark or light. We will do two things in our functions. The first is add a “dark“ class to our body element. This will trigger the css classes to be applied to the page. Secondly, add our chosen preference to local storage in the browser to we can persist the dark mode preference across all pages on the website and also remember the preference for when the user returns. // Helper Functions
const makeDark = () => {
        body.classList.add("dark");
        localStorage.setItem('darkMode', 'dark');
}

const makeLight = () => {
        body.classList.remove("dark");
        localStorage.setItem('darkMode', 'light');
} Melt the butter and add the flour… Check on startup for system preferences & check for local browser preferences. This is dealing with Logic ID’s 1 through 4 on my logic table. After the helper functions add the following code. // 1-4
if (window.matchMedia && window.matchMedia('(prefers-color-scheme: light').matches && localStorage.darkMode !== 'dark') {
    // System is light, website is light or no preference = Make light
    makeLight();
} 
else if (window.matchMedia && window.matchMedia('(prefers-color-scheme: light').matches && localStorage.darkMode === 'dark') {
    // System is light, website is dark = Make dark
    makeDark();
}
else if (window.matchMedia && window.matchMedia('(prefers-color-scheme: dark').matches && localStorage.darkMode !== 'light') {
    // System is dark, website is dark = Make dark
    makeDark();
}
else {
    // System must be dark, website must be light or no preference
    makeLight();
} Dealing with the user clicking the button… Listen for user clicks and dealing with logic IDs 5-8, which basically says if the user changes the darkmode, do exactly what they want. Therefore we can disregard the system preferences. // Add an event listener which checks for the button being pressed, do exactly what the button says
darkMode.addEventListener('click', function() {
    if (localStorage.darkMode === 'light') {
        makeDark();
    } else {
        makeLight();
    }
}); When the system switches preference This is where you could argue that user preference of the website should take precedence, but I think; if the user has not set a preference on the website and they have their system change dark mode preference based on the time of day, then the website should follow this. Also if they decide the system needs to be a specific preference and change to it manually, then the website should respect that decision and the user can change the website preferences if they do not want it to match system preferences. You could also add another button or a toggle which deals with this idea as another user preference. Rant over… Dealing with system preference changes // 9-12 Add an event listener which checks for system preference changes, do exactly what it says
window.matchMedia('(prefers-color-scheme: dark)').addEventListener('change', event => {
    if (event.matches) {
            makeDark();
    } else {
            makeLight();
    }
}); Javascript file is finished! The final JS file… // This checks to make sure the DOM had loaded properly before we start messing with it
document.addEventListener('DOMContentLoaded', function(event) {

    // Select the body element
    let body = document.querySelector('body')

    // Select the dark mode button
    let darkMode = document.querySelector('#darkmode-button');


    // Helper Functions
    const makeDark = () => {
        body.classList.add("dark");
        localStorage.setItem('darkMode', 'dark');
    }

    const makeLight = () => {
        body.classList.remove("dark");
        localStorage.setItem('darkMode', 'light');
    }


    // 1-4
    if (window.matchMedia && window.matchMedia('(prefers-color-scheme: light').matches && localStorage.darkMode !== 'dark') {
        // System is light, website is light or no preference = Make light
        makeLight();
    } 
    else if (window.matchMedia && window.matchMedia('(prefers-color-scheme: light').matches && localStorage.darkMode === 'dark') {
        // System is light, website is dark = Make dark
        makeDark();
    }
    else if (window.matchMedia && window.matchMedia('(prefers-color-scheme: dark').matches && localStorage.darkMode !== 'light') {
        // System is dark, website is dark = Make dark
        makeDark();
    }
    else {
        // System must be dark, website must be light or no preference
        makeLight();
    }


    // 5-8 Add an event listener which checks for the button being pressed, do exactly what the button says
    darkMode.addEventListener('click', function() {
        if (localStorage.darkMode === 'light') {
            makeDark();
        } else {
            makeLight();
        }
    });

    
    // 9-12 Add an event listener which checks for system preference changes, do exactly what it says
    window.matchMedia('(prefers-color-scheme: dark)').addEventListener('change', event => {
        if (event.matches) {
                makeDark();
        } else {
                makeLight();
        }
    });
}) Finally, the CSS So far, all we have seen is the body tag toggle with a class and the local storage change. .dark Here, we are going into , and adding darkmode specific styling. All I need for my site is two declarations and two selectors. Yours will likely be more complex. But remember all you need to do to change something in dark mode is write a declaration with body.dark preceding the selector. It is likely lots of elements in your page will have a similar style, so you can chain the selectors as I have done below… darkmode.css /* Darkmode Styling */

body.dark,
body.dark button  {
    background-color: black;
    color: white;
} THANKS FOR READING, Enjoy your websites cool new dark mode!

MassLight

masslight.com

-- employees

Since n.d.

COMPANY RANKING

MASSLIGHT

EVERGREEN INDEX #6418

MassLight WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!

MassLight

masslight.com

-- employees

Since n.d.

COMPANY RANKING

MASSLIGHT

EVERGREEN INDEX #6418

RELATED COMPANIESRANK

STORIES ABOUT MASSLIGHT

MassLight WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!