Classy is the world’s largest fundraising platform for social good organizations

BUILD LIFELONG RELATIONSHIPS FROM MOMENTS OF GENEROSITY Classy, a GoFundMe company, is a Public Benefit Corporation and giving platform that enables nonprofits to connect supporters with the causes they care about. Through technology, we empower nonprofits to unlock the generosity of their supporters and help them advance their missions. NONPROFIT RESOURCES Our team curates a library of resources with your success in mind. ・Blog - Fundraising and marketing best practices, industry trends, and more ・Webinars - On-demand access to insights from industry leaders ・Reports - The latest data on industry trends, giving behavior, and more. CLASSY CULTURE As part of the GoFundMe family, working at Classy is a unique and fulfilling experience where team members learn, create, and flourish with a group of passionate technologists working to mobilize and empower the world for good. PART OF THE GOFUNDME FAMILY Together, Classy and GoFundMe are a global giving platform that supports the largest giving community in the world. CLASSY AWARDS 2024 dates to be announced soon. Celebrating the impact of innovative nonprofits. The Classy Awards recognize nonprofits for their unique approaches and impact on our world. Winners are selected through a comprehensive evaluation process by a leadership council, a prestigious group of social sector leaders and executives. COLLABORATIVE BY CLASSY May 15-16, 2024 | Chicago Join other forward-thinking nonprofit leaders for this two-day conference that will uncover the ideas and strategies needed to propel our industry forward and help you raise more.

Classy.org

classyorg

HackerNoon, the independent technology publishing platform, is pleased to announce the nominees for its annual “Startups of the Year” award, featuring the most promising and innovative companies in the San Diego startup ecosystem. San Diego, CA - May 24, 2023 - https://www.youtube.com/watch?v=ZqIW54yMsNc&embedable=true The list, compiled by the HackerNoon team, showcases that are making significant contributions to the San Diego economy and driving innovation in their respective industries. 133 startups The nominated for Startups of the Year 2023 include: Startups in San Diego GoFormz Lively Root Platform Science Kahoona Tag-N-Trac Launch Factory comma Zoox Streamlined Robin Healthcare KÉXY ChargeNet Stations Replay RobustPhysics Sensorydata Skillmasters.io Truepic Blueboard 6Storage XRA Lawmatics Brain Doctible Classy.org Helix GoShare Sportidia The Good Face Project Cloudbeds ClickUp You can nominate your company as the . startup of the year in San Diego here “We are thrilled to recognize the top startups in San Diego and celebrate their achievements,” said . “Starting and sustaining a company is difficult. We’re honored to showcase their work and impact.” David Smooke, HackerNoon Founder & CEO is a community-driven voting platform that recognizes startups that are changing technology and the world for the better. Starting May 8th, 2023, the internet can nominate and vote for the best ventures in their city. The voting period will remain open until December 31, 2023, and winners will be announced in January 2024 after a comprehensive evaluation by the HackerNoon team. Startups of the Year 2023 In its , a total of 44,427 startups were nominated in 16 different regions, and the community cast 234,344 votes during a 6-month long campaign in favor of budding companies that were growing and trending across every major city in the world. The received perks from sponsors and a free from HackerNoon. previous iteration 1,382 winners tech company news page As a proponent of the open data movement, HackerNoon releases the unique social data gathered from Startups of the Year on GitHub as “ ” for valuable insights. /where-startups-trend Apart from validation from the world's greenest tech publication, all nominees relevant to their domain, region, and funding. They will also receive an and a free version of their very own on HackerNoon. get free interviews amazing discount package designed for their startup Tech Company News Page These pages include business overviews (such as head count, founding year, bio, social links, and domain ranking) coupled with dynamic updates every time the company is mentioned in HackerNoon stories or relevant headlines around the web. People can , and vote once per day per award for who they think should be Startup of the Year all the way up to December 31st. nominate their favorite startups until June 8th In addition to the award itself, winners receive exclusive interviews, an exclusive NFT from HackerNoon, and a .Tech Domain for life. For more information about the “Startups of the Year 2023” list and the nominated companies, please visit our . FAQ page About HackerNoon HackerNoon is a technology publication that aims to empower developers, entrepreneurs, and tech enthusiasts to share their knowledge and expertise with a global audience. With millions of monthly readers, over 500,000 followers on social media, and over 250,000 newsletter subscribers, HackerNoon provides a platform for startups and innovators to showcase their work and connect with a vibrant community of like-minded individuals. Did you know that companies that actively engage in blogging experience a whopping 67% increase in leads? Take advantage of HackerNoon's ' ' to kickstart your own company's blogging journey. Startups Package Startups Of The Year 2023 is sponsored by . .Tech Domains You can nominate your company as the . startup of the year in San Diego here

Startups of The Year 2023: 130+ Startups Nominated in San Diego

Using Arrow Flight SQL Protocol in Apache Doris 2.1 For Super Fast Data Transfer

Education is easy when it is fun! No one says “no” to a little fun. That’s what Blooket is all about. It’s an online app that allows you to learn and play using limited tokens (coins) once you join. But hey, there are legit Blooket hacks to enjoy unlimited play. Table of Content All There is to Know about Blooket Key Features of Blooket How to Join a Blooket How to Host a Blooket Game Blooket Hack for Tokens Unlimited Token Blooket Hacks. Closing Note All There is to Know about Blooket Blooket is an online educational gaming platform that allows teachers to create and customize games for their students. The platform is designed to make learning engaging and fun, using game-based activities to reinforce educational concepts. Although designed as an academic resource, it is also a , so people can win prizes and exchange items or game-based gifts with other players. game Here are some key features and aspects of Blooket: Teachers can create their own games or use pre-existing templates to develop quizzes, flashcards, and other educational activities. These games can cover a wide range of subjects and topics. Game Creation: Blooket provides customization options, allowing teachers to tailor games to suit their specific curriculum and learning objectives. That includes adding images, audio, and video content to enhance the learning experience. Customization: : Games on Blooket are often played in a live setting, where students can join in real-time. It finds application in for in-class competitions or remote learning scenarios. Live Mode Besides live games, Blooket offers a solo mode that allows students to play games individually at their own pace. It can be useful for homework assignments or independent study. Solo Mode: Blooket provides analytics and reports to help teachers track student progress and identify areas where additional support may be needed. Reports and Analytics: Blooket aims to be accessible and user-friendly, making it suitable for various educational settings and grade levels. Accessibility: Although designed for teachers but not limited to teachers, users can create their own games, and other users or students can join. Games on Blooket are often played in “live” mode. How to Join a Blooket Game There are three major ways to join a Blooket: with an ID or with a link. Any of the methods allow you to play on your mobile phone or a PC. Join Blooket with a Game ID Step 1:
Click “Join a game” on the .
Step 2:
You will input a game ID, which only the game host can give. Then, enter the game. home page Join via a Link Alternatively, you can get a direct link from the host, which can be generated from their screen or dashboard. Once they share that with you, you can join the game directly. Join Blooket with a QR Code Another way is to get the game’s QR code with your phone, and it will let you into a game room. Smartphone cameras, these days, can connect you to the internet when automatically scanning a QR code. Once you join a game of Blooket to answer questions and compete, you will have to first input a nickname for identification. After that, you will have to choose an emoji to represent your nickname. This emoji is known as a “blook.” How to Host a Blooket Game While Blooket was created with education and educators in mind, you can also use it to have fun, play other games, and do more challenges. You can host challenges and complete ones hosted by others, and you can even trade some of your “blooks” for tokens. To host a game, you must log in. Once logged in, you can create a game by Go to your browser. Create a set of questions and answers. Go live by clicking “Host.” Blooket Hack for Tokens: Go to your browser. Create a set where all the answers are right. Host. Choose factory Set time to 10 minutes. Open another browser and join the game with the game ID or any of the other methods above. Play the game and try to answer as many questions as possible within the 10 minutes. Completing the game will give you token rewards for correct answers. While you play, try to get the best factory blooks. Good blooks mean better token rewards. The tip to get real easy token rewards is getting blooks from a good pack while you play. It is even better if you get blooks from the same clan. If you want even more rewards, you can set the game you’re hosting to about 15 minutes. If clicking for 10 minutes straight is tedious for you, you can try some auto-clicker tools. You may, as well, watch a show or movie while at it. Alternatively, Follow the same steps (1-3) as above. Then, Go into “Solo” and select ‘Cafe or Host a Game’ for a plus bonus. Set the time, and there you go. This method allows you to spam the questions as many times as possible. Steps: 1: Join the game ID 2: Start the game. 3: Spam questions because you get to answer many times, and that gets you token rewards. 4. Once answered, you can get honored as 1st place, with that, you get 500 tokens, which is the max possible for a day. Earning the first place will present you with the wheel spin. With that, you can win even more tokens. With that, you get and max out daily tokens. Comparing both the ‘Factory’ and ‘Cafe’ Options What makes the ‘Factory’ better is that your cursor can be in a spot, and you can automate your click or manually click from a spot. With the cafe, however, you still need to make some mouse movements to restock and choose your answers. Playing for tokens is legit and safe; there is no risk of getting blocked or banned for cheating. Blooket Hack with Code There is another hack that some folks use. These people get source codes that can locally modify their computer to automatically claim the maximum daily rewards possible (500 tokens and 300 XP). I consider this inappropriate, and that’s why it is not included in this article. Plus, there is the possibility of getting your account suspended or blocked. It spoils the fun and ruins the chance of playing the game for others. For classwork, if you randomly throw the tokens around without working with them, then the purpose of education is not fulfilled. Unlimited Tokens Blooket Hacks? You have probably seen ad hooks for a countless number of tokens while playing Blooket. Well, since inception until now, there has been no such thing as unlimited tokens on Blooket. There are no unlimited tokens on Blooket. So, any hack that promises unlimited tokens is untrue. What you can only have is the maximum number of tokens per day, which is 500 tokens, not including bonuses from spinning a wheel. Closing Note Blooket is a smart, educational innovation. For me, I think the design is mid, too basic, works for kids, and lacks action. However, I understand that the target audience includes school teachers and little pens. There is a maximum amount of 500 tokens that can be won daily. More tokens mean you can solve all quizzes without having to worry about getting logged out. Other similar educational tools include Kahoot and Quizlet, which have better displays and interfaces but neither require tokens nor have gaming options. You can read how and level the playground. Anybrain is using AI anti-cheat to catch game cheaters

Easy Blooket Hacks to Help You Play More Games and Get More Tokens

আপনাকে আরও গেম খেলতে এবং আরও টোকেন পেতে সাহায্য করার জন্য সহজ ব্লুকেট হ্যাক

Einfache Blooket-Hacks, die Ihnen helfen, mehr Spiele zu spielen und mehr Token zu erhalten

Trucos sencillos de Blooket para ayudarte a jugar más juegos y obtener más tokens

Des astuces Blooket faciles pour vous aider à jouer à plus de jeux et à obtenir plus de jetons

अधिक गेम खेलने और अधिक टोकन प्राप्त करने में आपकी सहायता के लिए आसान ब्लूकेट हैक्स

より多くのゲームをプレイしてより多くのトークンを入手するのに役立つ簡単な Blooket ハック

더 많은 게임을 플레이하고 더 많은 토큰을 얻는 데 도움이 되는 쉬운 Blooket 해킹

Easy Blooket Hacks para ajudá-lo a jogar mais jogos e obter mais tokens

Простые хаки Blooket, которые помогут вам играть в больше игр и получать больше жетонов

Daha Fazla Oyun Oynamanıza ve Daha Fazla Jeton Kazanmanıza Yardımcı Olacak Kolay Blooket Tüyoları

Mẹo Blocket dễ dàng giúp bạn chơi nhiều trò chơi hơn và nhận được nhiều token hơn

简单的 Blooket 黑客可帮助您玩更多游戏并获得更多代币

In this article, we will see how can we perform operations with database using JDBC. We will then cover how to create a table in MySQL database and how to insert, update, and delete the rows using the JDBC program. crud MySQL You can find a video below with my step-by-step process. youtube https://www.youtube.com/watch?v=fUBoDErcDHA&embedable=true&transcript=true Let’s dive straight into the code Insert Class import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
public class Insert {
    public static void main(String[] args) {
        //load the driver
        try {
            Class.forName("com.mysql.cj.jdbc.Driver");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        try (Connection con = DriverManager.getConnection("jdbc:mysql://@localhost:3306/new_schema", "root", "root"); Statement st = con.createStatement();) {
            String query = "INSERT INTO EMP(EID,ENAME) values(1,'Ram')";
            int count = st.executeUpdate(query);
            if (count == 0) {
                System.out.println("Record not inserted");
            } else {
                System.out.println("Record Inserted");
            }
        } catch (SQLException se) {
            se.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
} Delete Class import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
public class Delete {
    public static void main(String[] args) {
        // load the driver
        try {
            Class.forName("com.mysql.cj.jdbc.Driver");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        try (Connection con = DriverManager.getConnection("jdbc:mysql://@localhost:3306/new_schema", "root", "root"); Statement st = con.createStatement();) {
            String query = "DELETE FROM EMP WHERE EID=1";
            int count = st.executeUpdate(query);
            if (count != 0) {
                System.out.println("Record Deleted");
            } else {
                System.out.println("Record Not Deleted");
            }
        } catch (SQLException se) {
            se.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
} Update Class import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
public class Update {
    public static void main(String[] args) {
        // load the driver
        try {
            Class.forName("com.mysql.cj.jdbc.Driver");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        try (Connection con = DriverManager.getConnection("jdbc:mysql://@localhost:3306/new_schema", "root", "root"); Statement st = con.createStatement();) {
            String query = "UPDATE EMP SET ENAME='SAM' WHERE EID=1";
            int count = st.executeUpdate(query);
            if (count != 0) {
                System.out.println("Record UPDATED");
            } else {
                System.out.println("Record Not UPDATED");
            }
        } catch (SQLException se) {
            se.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
} /Select Class import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class Select {
    public static void main(String[] args) {
        // load the driver
        try {
            Class.forName("com.mysql.cj.jdbc.Driver");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        try (Connection con = DriverManager.getConnection("jdbc:mysql://@localhost:3306/new_schema", "root", "root"); Statement st = con.createStatement();) {
            String query = "SELECT EID,ENAME FROM EMP";
            ResultSet rs = st.executeQuery(query);
            while (rs.next()) {
                System.out.println(rs.getInt(1) + " " + rs.getString(2));
            }
        } catch (SQLException se) {
            se.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
} The lead image for this article was generated by HackerNoon's AI Image Generator via the prompt "database".

Mastering Java JDBC CRUD Operations in Eclipse Using MySQL

The term "metaverse" has been a buzzword used throughout the tech industry for some time now, with everyone from gamers to investors scrambling to learn more about the potential of this new digital environment. However, the has impacts far beyond entertainment and commerce. metaverse Metaverse has the potential to revolutionize the way we approach education. Beyond virtual chat rooms and video games, the digital worlds of the metaverse can transport students to places they could have never imagined visiting through the power of virtual reality (VR) and augmented reality (AR) technology. From the ocean's depths to the surface of Mars, the possibilities the metaverse unlocks for truly immersive learning are seemingly boundless. Through these immersive experiences, students can enhance their understanding of complex concepts and help them retain information more effectively. that immersive technologies such as VR can improve memory recall, increase motivation, and improve classroom engagement in learners. For those who struggle with traditional classroom learning, these new technologies can give students a new way to succeed. Research has shown That means a more accessible and inclusive learning experience for all. The traditional classroom model doesn't work for everyone. The widening gap in student learning abilities combined with expanding class sizes across the country makes it challenging for teachers to provide a more typical, inclusive learning environment. The metaverse can offer a different and more inclusive approach by enabling students to participate in a virtual learning environment tailored to their needs. Students in rural or underserved areas who might not have access to specialized resources or high-quality education will also see benefits. Within the metaverse, these students can access the same high-quality content and experiences as students in more affluent areas, bridging the growing digital divide. However, the metaverse isn't only about the individual; it also offers opportunities for social connection and teamwork. Collaboration is the core component of many existing metaverse experiences, with users working together to solve puzzles, complete challenges, and build virtual worlds. Inside the classroom, students can collaborate on group projects, share ideas, and learn from one another. Beyond classwork, students can also develop essential social and emotional skills such as communication, teamwork, and problem-solving. These experiences help kids feel more connected to one another, which, in turn, can translate to them being more active in their communities and achieving higher academic success. The metaverse also has its challenges regarding education. The demand for infrastructure and technology support is among the main challenges the metaverse poses to schools. Schools must make the required hardware and software investments to construct and access the metaverse, which can become expensive depending on district sizes. With growing teacher shortages and tightening budgets, some schools need more resources to allocate to this technology. Additionally, a digital divide initially meant to be solved could be strained due to students needing the means or skills to use the equipment required at home. Finding qualified teachers who can use the metaverse effectively may still present its challenge, even with adequate resources. Teachers will need the training to develop a curriculum, promote learning, and control student behavior in virtual and conventional classrooms. A sizable investment in teacher development, training, and continued support is also necessary to guarantee that educators have the knowledge and tools they need to thrive. Finally, concerns about safety and may keep some educators on edge. Similar to any device connected to the Internet, the metaverse is susceptible to cyberbullying, harassment, and other types of online abuse. Schools must create policies and processes to safeguard their students online and stay up with and continually revise them based on these evolving digital environments. privacy within the metaverse Despite these challenges, the positive impact of the metaverse in education is almost impossible to ignore. By providing an immersive, inclusive, and collaborative learning experience, the metaverse can transform education and provide students with a learning experience that's (quite literally) out of this world. As technology evolves, parents, educators, administrators, and policymakers must remain on top of technological advancements and consider the opportunities the metaverse presents for education. Fortunately, there are a lot of pilot projects and partnerships that make it easy to integrate the metaverse into the classroom. Companies like can assist in bridging the technology and education divide and give students the skills they need to flourish in the digital era by collaborating with schools and other educational institutions. Tynker Ultimately, the metaverse is just one part of the growing toolkit of the modern educator. The challenge is ensuring that all key stakeholders, from policymakers, educators, parents, and   firms, can partner well. Through this collaboration, we can create a more immersive, inclusive, and collaborative learning experience that prepares students for success in the 21st century. Are you ready to plug in? About the Author is the Chief Growth Officer of Tynker, with 20 years of experience helping startups grow into successful businesses. Lomit Patel Lomit has previously played a critical role in scaling growth at startups, including Roku (IPO), TrustedID (acquired by Equifax), Texture (acquired. by Apple), and IMVU (#2 top-grossing gaming app). Lomit is a public speaker, author, and advisor with numerous accolades and awards throughout his career, including being recognized as a Mobile Hero by Liftoff. Lomit's book is part of Eric Ries' best-selling "The Lean Startup" series. Lean AI

The Potential Impact of the Metaverse on Education

El impacto potencial del metaverso en la educación

L'impact potentiel du métaverse sur l'éducation

शिक्षा पर मेटावर्स का संभावित प्रभाव

教育に対するメタバースの潜在的な影響

O impacto potencial do metaverso na educação

Tác động tiềm ẩn của Metaverse đối với giáo dục

元宇宙对教育的潜在影响

Welcome to other chapters of Let’s Understand Chrome V8 Dispatch is responsible for scheduling bytecode, which is equivalent to registering EIP++, and jumps to the next bytecode. Dispatch consists of two parts, one is a dispatch table and the other is the physical register. The table is an array that contains all bytecode addresses. V8 uses the physical register to dispatch bytecode for getting greater efficiency. 1. Dispatch Table The dispatch table is an array of pointers, which is used to store the address of the bytecode processing program. The array type is Code, and the Code Class is below: class Code: public HeapObject {
    public: NEVER_READ_ONLY_SPACE
    using Flags = uint32_t;
    #define CODE_KIND_LIST(V)\
    V(OPTIMIZED_FUNCTION)\
    V(BYTECODE_HANDLER)\
    V(STUB)\
    V(BUILTIN)\
    V(REGEXP)\
    V(WASM_FUNCTION)\
    V(WASM_TO_CAPI_FUNCTION)\
    V(WASM_TO_JS_FUNCTION)\
    V(JS_TO_WASM_FUNCTION)\
    V(JS_TO_JS_FUNCTION)\
    V(WASM_INTERPRETER_ENTRY)\
    V(C_WASM_ENTRY)
    enum Kind {
      #define DEFINE_CODE_KIND_ENUM(name) name,
        CODE_KIND_LIST(DEFINE_CODE_KIND_ENUM)
      #undef DEFINE_CODE_KIND_ENUM
      NUMBER_OF_KINDS
    };
    static
    const char * Kind2String(Kind kind);
    #ifdef ENABLE_DISASSEMBLER
    const char * GetName(Isolate * isolate) const;
    V8_EXPORT_PRIVATE void Disassemble(const char * name, std::ostream & os,
      Address current_pc = kNullAddress);
    #endif
    //................omit................
  }; : In the isolate, there is another pointer array that is the same type as the dispatch table. It holds all the Builtins addresses, which can confuse beginners easily. Note The dispatch table is maintained by BuildWithMacroAssembler, code is below: Code BuildWithMacroAssembler(Isolate * isolate, int32_t builtin_index,
    MacroAssemblerGenerator generator,
    const char * s_name) {
    HandleScope scope(isolate);
    // Canonicalize handles, so that we can share constant pool entries pointing
    // to code targets without dereferencing their handles.
    CanonicalHandleScope canonical(isolate);
    constexpr int kBufferSize = 32 * KB;
    byte buffer[kBufferSize];
    MacroAssembler masm(isolate, BuiltinAssemblerOptions(isolate, builtin_index),
      CodeObjectRequired::kYes,
      ExternalAssemblerBuffer(buffer, kBufferSize));
    masm.set_builtin_index(builtin_index);
    DCHECK(!masm.has_frame());
    generator( & masm);
    int handler_table_offset = 0;
    // JSEntry builtins are a special case and need to generate a handler table.
    DCHECK_EQ(Builtins::KindOf(Builtins::kJSEntry), Builtins::ASM);
    DCHECK_EQ(Builtins::KindOf(Builtins::kJSConstructEntry), Builtins::ASM);
    DCHECK_EQ(Builtins::KindOf(Builtins::kJSRunMicrotasksEntry), Builtins::ASM);
    if (Builtins::IsJSEntryVariant(builtin_index)) {
      handler_table_offset = HandlerTable::EmitReturnTableStart( & masm);
      HandlerTable::EmitReturnEntry( &
        masm, 0, isolate -> builtins() -> js_entry_handler_offset());
    }
    //.....................................................
    //................omit.............................
  } You can see regarding how to debug the BuildWithMacroAssembler. When the value of the parameter builtin_index is 65, the function pointer generator points to which is responsible for maintaining the Dispatch table, code is below: Chapter 9 Generate_InterpreterEnterBytecodeDispatch static void Generate_InterpreterEnterBytecode(MacroAssembler * masm) {
    // Set the return address to the correct point in the interpreter entry
    // trampoline.
    Label builtin_trampoline, trampoline_loaded;
    Smi interpreter_entry_return_pc_offset(
      masm -> isolate() -> heap() -> interpreter_entry_return_pc_offset());
    DCHECK_NE(interpreter_entry_return_pc_offset, Smi::kZero);
    // If the SFI function_data is an InterpreterData, the function will have a
    // custom copy of the interpreter entry trampoline for profiling. If so,
    // get the custom trampoline, otherwise grab the entry address of the global
    // trampoline.
    __ movq(rbx, Operand(rbp, StandardFrameConstants::kFunctionOffset));
    __ LoadTaggedPointerField(
      rbx, FieldOperand(rbx, JSFunction::kSharedFunctionInfoOffset));
    __ LoadTaggedPointerField(
      rbx, FieldOperand(rbx, SharedFunctionInfo::kFunctionDataOffset));
    __ CmpObjectType(rbx, INTERPRETER_DATA_TYPE, kScratchRegister);
    __ j(not_equal, & builtin_trampoline, Label::kNear);
    __ movq(rbx,
      FieldOperand(rbx, InterpreterData::kInterpreterTrampolineOffset));
    __ addq(rbx, Immediate(Code::kHeaderSize - kHeapObjectTag));
    __ jmp( & trampoline_loaded, Label::kNear);
    __ bind( & builtin_trampoline);
    // TODO(jgruber): Replace this by a lookup in the builtin entry table.
    __ movq(rbx,
      __ ExternalReferenceAsOperand(
        ExternalReference::
        address_of_interpreter_entry_trampoline_instruction_start(
          masm -> isolate()),
        kScratchRegister));
    __ bind( & trampoline_loaded);
    __ addq(rbx, Immediate(interpreter_entry_return_pc_offset.value()));
    __ Push(rbx);
    // Initialize dispatch table register.
    __ Move(
      kInterpreterDispatchTableRegister,
      ExternalReference::interpreter_dispatch_table_address(masm -> isolate()));
    // Get the bytecode array pointer from the frame.
    __ movq(kInterpreterBytecodeArrayRegister,
      Operand(rbp, InterpreterFrameConstants::kBytecodeArrayFromFp));
    if (FLAG_debug_code) {
      // Check function data field is actually a BytecodeArray object.
      __ AssertNotSmi(kInterpreterBytecodeArrayRegister);
      __ CmpObjectType(kInterpreterBytecodeArrayRegister, BYTECODE_ARRAY_TYPE,
        rbx);
      __ Assert(
        equal,
        AbortReason::kFunctionDataShouldBeBytecodeArrayOnInterpreterEntry);
    }
    // Get the target bytecode offset from the frame.
    __ movq(kInterpreterBytecodeOffsetRegister,
      Operand(rbp, InterpreterFrameConstants::kBytecodeOffsetFromFp));
    __ SmiUntag(kInterpreterBytecodeOffsetRegister,
      kInterpreterBytecodeOffsetRegister);
    // Dispatch to the target bytecode.
    __ movzxbq(r11, Operand(kInterpreterBytecodeArrayRegister,
      kInterpreterBytecodeOffsetRegister, times_1, 0));
    __ movq(kJavaScriptCallCodeStartRegister,
      Operand(kInterpreterDispatchTableRegister, r11,
        times_system_pointer_size, 0));
    __ jmp(kJavaScriptCallCodeStartRegister);
  }
  //================================separation=========================
  void Builtins::Generate_InterpreterEnterBytecodeDispatch(MacroAssembler * masm) {
    Generate_InterpreterEnterBytecode(masm);
  } In the above code, the is the entry point of bytecode dispatch, and the is the key code that implements the bytecode dispatch. Here are two important concepts: Generate_InterpreterEnterBytecodeDispatch Generate_InterpreterEnterBytecode The is a Builtin and its index is 65. (The index may be dissimilar in different V8 versions) Generate_InterpreterEnterBytecodeDispatch V8 uses a physical register to manage the dispatch table, the name of the register is . Using the physical register can avoid the push and pop of the dispatch table frequently, to improve efficiency. kInterpreterDispatchTableRegister Here are the key lines of code： Line 35, loads the dispatch table to the A register. Line 37 of code, take out the table address from the isolate. The implementation of A is in the below three functions. (1) ExternalReference ExternalReference::interpreter_dispatch_table_address(
  Isolate * isolate) {
  return ExternalReference(isolate -> interpreter() -> dispatch_table_address());
}
interpreter::Interpreter * interpreter() const {
  return interpreter_;
}
Address dispatch_table_address() {
  return reinterpret_cast < Address > ( & dispatch_table_[0]);
} Line 39 takes out the bytecode array from the stack. (2) Line 51 takes out the offset of the target bytecode from the bytecode array. (3) Lines 56 and 58 calculate the target bytecode address and store the address in kJavaScriptCallCodeStartRegister. (4) Line 61 jumps to register kJavaScriptCallCodeStartRegister and executes bytecode. Figure 1 is the call stack. (5) 2. TailCall The Dispatch() is the last step in a bytecode, so its alias is the tail call. Let’s look at a few bytecodes： IGNITION_HANDLER(StaGlobal, InterpreterAssembler) {
    TNode < Context > context = GetContext();
    //omit..............
    Goto( & end);
    Bind( & no_feedback);
    CallRuntime(Runtime::kStoreGlobalICNoFeedback_Miss, context, value, name);
    Goto( & end);
    Bind( & end);
    Dispatch(); // !!! this is the tail call.
  }
  IGNITION_HANDLER(LdaContextSlot, InterpreterAssembler) {
    TNode < Context > context = CAST(LoadRegisterAtOperandIndex(0));
    TNode < IntPtrT > slot_index = Signed(BytecodeOperandIdx(1));
    TNode < Uint32T > depth = BytecodeOperandUImm(2);
    TNode < Context > slot_context = GetContextAtDepth(context, depth);
    TNode < Object > result = LoadContextElement(slot_context, slot_index);
    SetAccumulator(result);
    Dispatch(); //!!! here also is.
  }
  IGNITION_HANDLER(LdaImmutableContextSlot, InterpreterAssembler) {
    TNode < Context > context = CAST(LoadRegisterAtOperandIndex(0));
    TNode < IntPtrT > slot_index = Signed(BytecodeOperandIdx(1));
    TNode < Uint32T > depth = BytecodeOperandUImm(2);
    TNode < Context > slot_context = GetContextAtDepth(context, depth);
    TNode < Object > result = LoadContextElement(slot_context, slot_index);
    SetAccumulator(result);
    Dispatch(); //!!! here 
  } The above three bytecodes all end with Dispatch(). Below is the code of Dispatch: void InterpreterAssembler::Dispatch() {
    Comment("========= Dispatch");
    DCHECK_IMPLIES(Bytecodes::MakesCallAlongCriticalPath(bytecode_), made_call_);
    TNode < IntPtrT > target_offset = Advance();
    TNode < WordT > target_bytecode = LoadBytecode(target_offset);
    if (Bytecodes::IsStarLookahead(bytecode_, operand_scale_)) {
      target_bytecode = StarDispatchLookahead(target_bytecode);
    }
    DispatchToBytecode(target_bytecode, BytecodeOffset());
  } The 2nd line is the comment function. When debugging, we can use its output information to locate the execution position. The 4th line takes out the offset of the target(next) bytecode. The 5th line loads the target bytecode. The 9th line calls which calls eventually. DspatchToBytecode() DispatchToBytecodeHandlerEntry() void InterpreterAssembler::DispatchToBytecodeHandlerEntry(
  TNode < RawPtrT > handler_entry, TNode < IntPtrT > bytecode_offset) {
  // Propagate speculation poisoning.
  TNode < RawPtrT > poisoned_handler_entry =
    UncheckedCast < RawPtrT > (WordPoisonOnSpeculation(handler_entry));
  TailCallBytecodeDispatch(InterpreterDispatchDescriptor {},
    poisoned_handler_entry, GetAccumulatorUnchecked(),
    bytecode_offset, BytecodeArrayTaggedPointer(),
    DispatchTablePointer());
} In , parameter 1 is the target bytecode and 2 is the offset of the bytecode. Parameter 1 is used to load the bytecode handler and 2 is used to load operands. Then call , which is below: DispatchToBytecodeHandlerEntry TailCallBytecodeDispatch template < class...TArgs >
    void CodeAssembler::TailCallBytecodeDispatch(
      const CallInterfaceDescriptor & descriptor, TNode < RawPtrT > target,
        TArgs...args) {
      DCHECK_EQ(descriptor.GetParameterCount(), sizeof...(args));
      auto call_descriptor = Linkage::GetBytecodeDispatchCallDescriptor(
        zone(), descriptor, descriptor.GetStackParameterCount());
      Node * nodes[] = {
        target,
        args...
      };
      CHECK_EQ(descriptor.GetParameterCount() + 1, arraysize(nodes));
      raw_assembler() -> TailCallN(call_descriptor, arraysize(nodes), nodes);
    } In the above code, the 5th line creates the descriptor, as below: CallDescriptor * Linkage::GetBytecodeDispatchCallDescriptor(
    Zone * zone,
    const CallInterfaceDescriptor & descriptor,
      int stack_parameter_count) {
    const int register_parameter_count = descriptor.GetRegisterParameterCount();
    const int parameter_count = register_parameter_count + stack_parameter_count;
    DCHECK_EQ(descriptor.GetReturnCount(), 1);
    LocationSignature::Builder locations(zone, 1, parameter_count);
    locations.AddReturn(regloc(kReturnRegister0, descriptor.GetReturnType(0)));
    for (int i = 0; i < parameter_count; i++) {
      if (i < register_parameter_count) {
        // The first parameters go in registers.
        Register reg = descriptor.GetRegisterParameter(i);
        MachineType type = descriptor.GetParameterType(i);
        locations.AddParam(regloc(reg, type));
      } else {
        int stack_slot = i - register_parameter_count - stack_parameter_count;
        locations.AddParam(LinkageLocation::ForCallerFrameSlot(
          stack_slot, MachineType::AnyTagged()));
      }
    }
    MachineType target_type = MachineType::Pointer();
    LinkageLocation target_loc = LinkageLocation::ForAnyRegister(target_type);
    const CallDescriptor::Flags kFlags =
      CallDescriptor::kCanUseRoots | CallDescriptor::kFixedTargetRegister;
    return new(zone) CallDescriptor( // --
      CallDescriptor::kCallAddress, // kind
      target_type, // target MachineType
      target_loc, // target location
      locations.Build(), // location_sig
      stack_parameter_count, // stack_parameter_count
      Operator::kNoProperties, // properties
      kNoCalleeSaved, // callee-saved registers
      kNoCalleeSaved, // callee-saved fp
      kFlags, // flags
      descriptor.DebugName());
  } In , parameter 2 is the target bytecode, and parameter 3 is the stack parameter count. This function is used to apply for register resources and create a . The gives what parameters to supply when executing a bytecode. The comments on lines 24 to 25 give its layout. GetBytecodeDispatchCallDescriptor CallDescriptor CallDescriptor In , the on the 9th line is below, we see that it’s parameter 1 is . TailCallBytecodeDispatch TailCallN() CallDescriptor void RawMachineAssembler::TailCallN(CallDescriptor * call_descriptor,
    int input_count, Node *
    const * inputs) {
    // +1 is for target.
    DCHECK_EQ(input_count, call_descriptor -> ParameterCount() + 1);
    Node * tail_call =
      MakeNode(common() -> TailCall(call_descriptor), input_count, inputs);
    schedule() -> AddTailCall(CurrentBlock(), tail_call);
    current_block_ = nullptr;
  } The 5th line generates a node. In the 7th line adds the node to the end of the current basic block. So far, the dispatch is completed and the next bytecode is started to execute. Figure 2 shows the function call stack. AddTailCall() Okay, that wraps it up for this share. I’ll see you guys next time, take care! Please reach out to me if you have any issues. : qq9123013 : v8blink@outlook.com WeChat Email Also published . here

Let's Understand Chrome V8 — Chapter 11: Bytecode Dispatch 

WorkManager is ubiquitous in modern android development. We use it to run any background work which should not be bound to the application process lifecycle. It was first introduced in May 2018 and replaced several scheduling frameworks. The library unifies it all with a concise and simple API. You no longer have to orchestrate JobScheduler, GcmNetworkManager, Evernote AndroidJob, and so on. In fact, this new API is saving us quite a lot of maintenance work, but is it perfect? There are a few rough areas we’ll explore in this article. Dependency injection It’s hard to imagine a modern production-grade android application without dependency injection. In our example, we’ll use Dagger2, but the principle will remain the same for any DI framework. Consider that you have a job that runs every hour. Its purpose is to delete old telemetry records from an SQLite database. The naive approach would be to create a component inside the worker and call : inject class CleanTelemetryWorker(context: Context, params: WorkerParameters) : Worker(context, params) {

    @Inject
    lateinit var telemetryRepository: TelemetryRepostory

    init {
        CleanTelemetryWorkerComponent.Factory.create(context).inject()
    }

    override fun doWork(): ListenableWorker.Result {
        telemetryRepository.clean()
    }
} This solution is not ideal for a few reasons: The dependency inversion principle breaks since the component should not know how to get its dependencies This worker is hard to test because there’s no easy way to mock dependencies, but we’ll get to it later What we want is to be able to declare any worker like this: class CleanTelemetryWorker @Inject constructor(
        context: Context, 
        params: WorkerParams,
        telemetryRepository: TelemetryRepository,
        ...//any other external dependencies
) Can we do better? We can! As you may know, we can customize WorkManager using the class: Configuration class MyApplication() : Application(), Configuration.Provider {
     override fun getWorkManagerConfiguration() =
           Configuration.Builder()
                .setMinimumLoggingLevel(android.util.Log.INFO)
                .setWorkerFactory(myCustomWorkerFactory)
                .build()
} You override in your class and provide a config object. The most important part here is the method. It allows us to pass a component that will create jobs for us. It sounds like the ideal place to inject our dependencies into workers. getWorkManagerConfiguration Application setWorkerFactory has only one method we can override, and it’s called… : WorkerFactory createWorker class CustomWorkerProvider {
    override createWorker(appContext: Context, 
                          workerClassName: String, 
                          workerParameters: WorkerParameters): ListenableWorker? {
        //We need to provide workers here. 
    } 
} Now we can provide arguments into our worker’s constructor. Fortunately, we don't have to do it ourselves. There exists this handy tool to generate dependency provision for us called Dagger 2. Let’s try to create a simple and robust schema to inject dependencies into workers. Of course there’s plenty of ways to do this, but let’s start simple and then add some options to it as we go. So what exactly do we need to create a worker? The class has two required dependencies: and . Let’s start with the dagger component that we will init in the function. ListenableWorker Context WorkerParameters WorkerComponent createWorker @Component
interface WorkerComponent {
    @Component.Factory
    interface Factory {
        fun create(
          @BindsInstance context: Context,
          @BindsInstance workerParameters: WorkerParameters,
        ): WorkerComponent
    }
} We use annotation to tell dagger to create an implementation of which will return us the implementation. Component.Factory WorkerComponent.Factory WorkerComponent annotation in the factory’s method means that this component should be able to provision and using the objects we passed to the method. @BindsInstance create Context WorkParameters Cool, we can now provide workers by adding a method that returns a concrete worker class, like CleanTelemetryWorker @Component(dependencies=[ApplicationComponent::class])
interface WorkerComponent {

   @Component.Factory
   interface Factory {
        fun create(
          applicationComponent: ApplicationComponent,
          @BindsInstance context: Context,
          @BindsInstance workerParameters: WorkerParameters,
        ): WorkerComponent
   }

   fun cleanTelemetryWorker(): CleanTelemetryWorker
...
} Notice that we need to add dependencies to the component’s annotation because by itself can’t provide you with anything other than and . We also have to pass the dependency component as a factory argument. WorkerComponent Context WorkerParameters Let’s see how the will look like now: CustomWorkerProvider class CustomWorkerProvider(private val applicationComponent: ApplicationComponent) {
    override createWorker(appContext: Context, 
                          workerClassName: String, 
                          workerParameters: WorkerParameters): ListenableWorker? {
        val component = DaggerWorkerComponent.factory().create(applicationComponent, appContext, workerParameters)
        when(workeClassName) {
          ClientTelemetryWorker::class.qualifiedName -> component.cleanTelemetryWorker()
          ...
        }
    } 
} It looks much better, but every time we add a new worker, we have to provide it here and add a new function definition to the component. Can dagger2 help us with this? Dagger Multibinding! With dagger multi binding, we can declare a module for each worker which will provide a worker provider in a map, where keys are the java classes of the workers. @Module
interface CleanTelemetryWorkerModule {
    @Binds
    @IntoMap
    @ClassKey(CleanTelemetryWorker::class.java)
    fun bindCleanTelemetryWorker(cleanTelemetryWorkerProvider: Provider<CleanTelemetryWorker>): Provider<out ListenableWorker>
} Let’s add this module to the component: @Component(dependencies=[ApplicationComponent::class], 
           modules=[CleanTelemetryWorkerModule::class],)
interface WorkerComponent {
    ...
} And finally, our will look like this: CustomWorkerProvider class CustomWorkerProvider(private val applicationComponent: ApplicationComponent) {
    override createWorker(appContext: Context, 
                          workerClassName: String, 
                          workerParameters: WorkerParameters): ListenableWorker? {
        val component = DaggerWorkerComponent.factory().create(applicationComponent, appContext, workerParameters)
        val workerProvidersMap = component.workerProvidersMap()
        return workerProvidersMap[Class.forName(workerClassName)]!!.get()
    } 
} Every time you have to add a new job, you’ll only have to create a new module and attach it to the . Neat, right? WorkerComponent Why does it matter, after all? The jobs now look like any other class with externally declared dependencies. It allows us to enforce the dependency inversion principle of SOLID.
With the relatively small overhead, we achieve the following benefits: Testability We can mock job dependencies or pass different implementations at any time. Jobs are not aware of the dependency inversion framework. If you choose to switch from Dagger 2 to any other DI framework, your jobs will remain the same. The only thing that will change is the external glue. Ease of support Reducing mental stress on the developers is also a thing. Previously every time you created a job, you had to think about how to get your dependencies there. It’s not always trivial, especially if your dependency graph has different scopes. In the following article, we’ll reap the benefits of this setup and explore how to properly test your workers now that we have an easy way to mock the dependencies. I hope this article was helpful! Let me know what you think :)

How to Cook WorkManager with Dagger 2

I am a big fan of leet code so when we decided to have a code challenge in our team I thought it wouldn’t be a bad idea to build one which should include pretty basic functionalities like: Ability to register and sign in to the application Present the problem (questions) Provide an interface for the end-users to write, compile and execute code. Overall, it was an amazing learning experience and I am happy to walk through how I did it. Guidelines Before I start working on this I decided to come up with some guidelines so I don't over-engineer this and end up building a Frankenstein out of it, here are few of those guidelines: The whole system should be implemented in 3 to 4 days Reuse as much as you can when it comes to technology or service. build anything new unless until it doesn't exist DON'T standing cost for the infrastructure. Pay for what you use and pay as you can ZERO ONLY MINIMAL Technologies & Runtime Services + JQuery (UI) Bootstrap AWS Lambda AWS API Gateway AWS Dynamodb AWS Dynamodb streams AWS Simple email service (SES) AWS S3 (For static site hosting) High-level Architecture The system consists of four keys functionalities based on which these modules are designed: Registration & sign-in Compile & Execute Score Calculator Winner Predictor Registration & Sign-in Flow We have a single lambda function that takes care of registering a new user and authenticating an existing user in the application. Part of registration flow user enters “FirstName”, “LastName” & “Email address” which is passed in as “QueryParam” to API gateway. Gateway invokes a Lambda function which takes care of saving the user details in DynamoDb, generating a random registration code (UUID based) and sending it in an email to the registered email address The sign-in flow will authenticate the user with the passed in email address and UUID using the Lambda function Compile & Execute When the user submits the code, the web application will call the API gateway with the following parameters: QuestionsId User types code Registration code API gateway will invoke the lambda function which will get information about the question/problem statement from the “Questions” table in Dynamodb (data looks like below). From the table data, we take the “GeneratedCode” attribute value and replace various tokens like — name — , — codeworking — & — testcases — with the class name (generated), the user typed code, and test cases (from columns “Test_1”… “Test_N”). Here is how the replaced code will look: { { { count= ; index= ; ( ){ {
                  s.charAt(index++);
                  count++;
              } (Exception e){ ;
              }
          } count;
      }
   } { actual= ; expected = ;
        String input = ; input = ;
        expected = ;
        actual = Solution.calculate(input); actual == expected :  String.format( , input, expected, actual);
    }
} // --name-- public class f_sdsds_a11223_dd // --codeworking-- static class Solution public static int calculate (String s) int 0 int 0 while true try catch break return public static void main (String args[]) int 0 int 3 null // --testcases-- "Hi1" 3 assert "--helper-- Input %s -> Expected = %s but got = %s" Since Lambda containers don't have JDK installed we have to package “tools.jar” inside the deployment package so we can run the compilation inside the containers, here is the code snippet on how we run compile inside lambda: (StringInputStream inputStream = StringInputStream(data);
     ByteArrayOutputStream outputStream = ByteArrayOutputStream();
     ByteArrayOutputStream errorOutputStream = ByteArrayOutputStream()) {
    Class<?> javacTool = Class.forName( );
    Method create = javacTool.getMethod( );
    JavaCompiler compiler = (JavaCompiler) create.invoke( );
    compiler.run(inputStream, outputStream, errorOutputStream, path.toFile().getAbsolutePath()); ProcessResponse(replaceNewLine(outputStream), replaceNewLine(errorOutputStream));
} (Exception e) { ProcessResponse( , + e.getMessage());
} try new new new "com.sun.tools.javac.api.JavacTool" "create" null return new catch return new null "Compilation error --> " If compilation is successful, we run the generated class which contains the test cases. java -ea -cp /tmp/f_sdsds_a11223_dd If execution is successful without any assertion failures, execution time is stored in “UserSubmission” table. Score Calculator We utilize DynamoDB streams to update the total points and total execution time for any given user. A lambda function listens to all updates done on “UserSubmission” table and performs these calculations once the submission is successful. Winner Predictor To find the winners, we run a simple query to get the top 3 rows in “UserStastics” table generated by sorting “TotalPoints” column in descending order and “TotalExecution” column in ascending Demo Here is the demo of the application: I know this doesn't solve all the use cases that a popular code challenge websites like “leetcode” or “topcoder” solves. But this is a good start & foundation which we can keep adding on. If you like this post then leave a comment. That way, I know you have made it all the way to the end 😀 . Thanks again for reading. Previously published at https://medium.com/javarevisited/build-code-challenge-application-23aa40d183fa

Leetcode Coding Challenge Using Lambda

It all started with video games. My first was Super Mario Bros. 3 for the Nintendo Entertainment System, still one of my favorite games of all time (my cousin taught me all 3 warp whistle locations). I was enchanted by these little worlds, stuffed into microchips, packaged in plastic cartridges, sitting in a cardboard box in my room. On an outdated, off-color TV I would explore these worlds. My parents upgraded me from the NES to a cheap, used PlayStation, which I thoroughly enjoyed and appreciated, my first game being the legendary . I remember one of my cousins remarking how incredible the graphics were! It was truly a sight to see, compared to the NES, although we’re spoiled by today’s standards. I went to Blockbuster, rented the latest titles I heard about in GamePro magazine, and generally had a blast. Crash Bandicoot Then we got a PC. Mind you, this was 20 years ago, in 1999, when I was 8 years old. Most families didn’t have a computer where I lived, in those days, unless it was some old DOS relic. However, a kind, caring teacher, who saw how I took to the machine in class, suggested to my parents that it would be a good idea to get a home computer running Windows (thank you Ms. Smith!). We got a Gateway computer, a mid-range PC capable of surfing the web on Windows 98 (we had a million AOL discs, but ended up using a cheaper ISP pushed by Kmart, called Blue Light). More important than the web: it could play games. We had The Neverhood. We had Carmen Sandiego. We had Oregon Trail. These were fun to me as a child, and The Neverhood still has some of the best claymation art to this day, but they weren’t the best games. I was an avid reader of GamePro, and later, Electronic Gamer Monthly. It was rare that either of them wrote about PC games, but they had to mention some of the greats, for comparison’s sake if nothing else. They raved about games like EverQuest and Diablo II, and of course, Doom and Quake. When I was 13, I found an article in GamePro about how games are made. It talked about “game engine programmers”, these wielders of arcane black magic that would make a computer do your bidding. It made programming sound approachable, even fun! That, combined with a blurb about David Kushner’s , led me to buy said book and tear through it like a demon. Masters of Doom John Carmack became one of my heroes. I read about and identified with parts of his childhood, like not having the computing power to realize your dreams, and wanting to create virtual worlds. I wanted to be just like him. So naturally, I picked up a copy of the book Carmack read on his way to hackerdom: by Steven Levy. Hackers: Heroes of the Computer Revolution This book became my bible. I read about the first computer-generated music. I read about a Craigslist-like bulletin board built in the 70s. I read about the first game programmers, and galvanized, energized, gung-ho, I set out to become a hacker myself. Where did I start? There was “How to Become a Hacker” by Eric S. Raymond, which became a field guide of sorts, telling me the steps I had to take to be considered a hacker. I took the first step, installed Linux, and dove into a rabbit hole I didn’t come up from for 5 years. I felt I had to learn everything about the system, and although I tried a couple of “Teach Yourself Game Programming in 24 Hours”-style books, programming didn’t stick at the time, didn’t really click (it’s no great surprise -- these books taught C++, using the Windows APIs and DirectX, far too advanced for a budding programmer). I became a Linux fiend. When my family’s computer broke down, and we couldn’t afford to replace it, I built PCs out of junk boxes that were thrown on the curb as garbage around my neighborhood, gathered by my dad and brother on scrap metal searches. I had to run the most minimal Linux builds I possibly could to squeeze power out of these puny systems -- at one point I had 12 PCs stacked in my closet (and one server I could never get running), half of them functional in some form, the rest set aside for future use. When it came time for college, I knew what I wanted to study: Computer Science. Maybe the gurus of the CS department could tell me what I had been missing when it came to programming. At Jackson Community College, I found my guru in the form of an Adjunct Professor who had been a programmer and system administrator for over 20 years: Dale Fay. Dale encouraged me to work on my own projects after I completed classwork, taught me countless Unix tips, tricks, and tools I use to this day, but most importantly, he showed me a language that would change my life. Perl. It may be ugly, but boy, does it get the job done! Combined with my ever-growing Linux skills, Perl was like a breath of fresh air after my experience with C++. As opposed to my futile attempts to push C++, Perl was useful. It was practical. It could do stuff, fast. Before I knew it I was automating away sysadmin tasks, generating config files, keeping track of album release dates, and itching for more...but our web programming segment was in PHP. Suffice it to say, I didn’t quite take a shine to PHP. I know now that Perl can be used in web programming (to great effect!), but at the time, I was in way over my head. I needed something easier to wrap my head around. That’s where I found Python. Python was presented to me as a sort of alternative to Perl, again, by Eric Raymond. He showed how a thorny configuration issue could be solved with ease, with readable code even to a noob like me. What’s more, he did some metaprogramming, generating code with code, that would later prove to be an inspiration for my adventures in Lisp. But that’s another story. With Python, came Django, the biggest, baddest library for Python, tailor-made for making web apps (it was naturally a bit server-heavy, by today’s standards, though that’s shifting back again). With Django, everything clicked. Everything had a place and a function, and thanks to the excellent documentation, I devoured it all. I learned about requests and responses, CSRF, URL encoding...I learned about everything I could get my hands on. Python was a natural language for a beginner, almost the perfect language for a beginner. It’s expressive, but terse -- you don’t have to write a lot of code to do a lot. It’s an explicit language. It does what you tell it to, no more, no less. What if we wanted more? What if we wanted...magic? , by (aka _why), is the ultimate programming book, the pinnacle of technical writing. Casting aside the bone-dry tone adopted by most technical books, _why rants and raves like a madman about the beauty of Ruby, an elf and his pet ham, “chunky bacon”, and a wild assortment of other delightful nonsense that helps break up the technical jargon. It’s geared towards beginners, but I’d recommend it to anyone who wants to know more about coding, or anyone seeking to improve their technical writing. Why’s (poignant) Guide to Ruby Why the Lucky Stiff In the midst of _why’s mad genius, I fell in love with Ruby. Unlike Python, it had a touch of magic, an endless source of debate in Python vs. Ruby threads. It makes assumptions. It usually does what you want the first time, even if you’re guessing common method names. Rails, the de facto official web framework and the most popular library for Ruby, takes this a step further by advocating “convention over configuration”. With those assumptions, you can write code that’s extremely expressive in a small space without sacrificing readability. Rails is where I hit my stride. I made a rudimentary todo app, a bug tracker, and an accounting app. By this time, I had dropped out of college, deciding to look for a real programming job instead. I still don’t know whether I should regret this decision to drop out, but at the end of the day, I traded one life experience for another, and I honestly couldn’t see my life any other way now. I wouldn’t recommend that you, the reader, should drop out of college, but personally, I wouldn’t trade my experience for anything. With my bare-bones apps in tow, ugly as sin, I started submitting applications to every startup that sounded interesting. In that process, I applied to a little startup called Saygent that was working on audio analysis. As I had plugged my guitar into my computer and analyzed the sound waves with Python, a couple of years prior, this seemed like the perfect fit. I told them so, and a couple of months later, I heard back from , my future friend and mentor. They sent me a tech challenge, I passed it, they flew me out to Silicon Valley, and I managed to land my first gig at an actual startup! Dane Lyons My career is fairly well-documented on my LinkedIn and AngelList profiles, but it’s not often you get to hear what led someone up to that point. I hope this has been enjoyable to read, and I truly hope it inspires someone out there to pick up coding as a hobby, as a thrilling exercise in creativity. How did you start hacking? Share your story in the comments section!

How I Started Hacking

Image classification using PyTorch for dummies Source Facebook recently released its deep learning library called PyTorch 1.0 which is a stable version of the library and can be used in production level code. I’m a part of Udacity’s PyTorch Scholarship Challenge program and learned a lot about PyTorch and its function. Coming from keras, PyTorch seems little different and requires time to get used to it. In this article, I’ll be guiding you to build a binary image classifier from scratch using Convolutional Neural Network in PyTorch. The whole process is divided into the following steps: 1. Load the data2. Define a Convolutional Neural Network3. Train the Model4. Evaluate the Performance of our trained model on a dataset 1. Load the data When comes to loading/ preprocessing the data PyTorch is much simpler as compared to other libraries. However, PyTorch has a built-in function called transforms using which you can perform all your pre-processing tasks all at once which we’ll see in a while. For the dataset, I couldn’t find one with the faces as positive labelled, therefore I made my own dataset manually by using the images from for positives and added some random images for the negatives which includes the images of vehicles, animals, furniture etc. If you want, you can download the dataset from here: LFW Face Dataset link The data needs to be split in Train, Test and validation set before training. Train set will be used to train the model, validation set will be used for validating the model after each epoch, and the Test set will be used to evaluate the model once it is trained. First, we need to get the dataset into the environment, which can be done by:( ) Note: ‘face’ is the name of the directory which contains a positive and negative example of faces train_data = datasets.ImageFolder('face',transform=transform) We’ll also need to define a transform object to perform the preprocessing steps. We can mention in the object what types of processing we need. In the following code, I have defined the transform object which performs Horizontal Flip, Random Rotation, convert image array into PyTorch (since the library only deals with Tensors, which is analogue of numpy array) and then finally normalize the image. transform = transforms.Compose([transforms.RandomHorizontalFlip(),transforms.RandomRotation(20),transforms.ToTensor(),transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))]) Once we are done with the loading the dataset and defining transform object we can split the dataset into train, test and validation sets as discussed before. For carrying out splits: #For testnum_data = len(train_data)indices_data = list(range(num_data))np.random.shuffle(indices_data)split_tt = int(np.floor(test_size * num_data))train_idx, test_idx = indices_data[split_tt:], indices_data[:split_tt] #For Validnum_train = len(train_idx)indices_train = list(range(num_train))np.random.shuffle(indices_train)split_tv = int(np.floor(valid_size * num_train))train_idx, valid_idx = indices_train[split_tv:],indices_train[:split_tv] # define samplers for obtaining training and validation batchestrain_sampler = SubsetRandomSampler(train_idx)test_sampler = SubsetRandomSampler(test_idx)valid_sampler = SubsetRandomSampler(valid_idx) #Loaders contains the data in tuple format# (Image in form of tensor, label)train_loader = torch.utils.data.DataLoader(train_data, batch_size=batch_size, sampler=train_sampler, num_workers=1) valid_loader = torch.utils.data.DataLoader(train_data, batch_size=batch_size, sampler=valid_sampler, num_workers=1) test_loader = torch.utils.data.DataLoader(train_data, sampler = test_sampler, batch_size=batch_size,num_workers=1) # variable representing classes of the imagesclasses = [0,1] The train_loader, test_loader and valid_loader will be used to pass the input to the model. Here are some random images from the dataset after applying transformations which includes resizing, random rotation, Normalizing: 2. Initialising the Convolutional Neural Network(CNN) The CNN in PyTorch is defined in the following way: torch.nn.Conv2D(Depth_of_input_image, Depth_of_filter, size_of_filter, padding, strides) Depth of the input image is generally 3 for RGB, and 1 for Grayscale. Depth of the filter is specified by the user which generally extracts the low level features, and the size of the filter is the size of the kernel which is convolved over the whole image. To calculate the dimension of the new convolution layer, the following formula is used: dimension=(dimen_of_input_image- Filter_size(int)+(2*padding))/stride_value + 1 Now it’s time to initialise the model: class Net(nn.Module):def __init__(self):super(Net, self).__init__()# convolutional layerself.conv1 = nn.Conv2d(3, 16, 5)# max pooling layerself.pool = nn.MaxPool2d(2, 2)self.conv2 = nn.Conv2d(16, 32, 5)self.dropout = nn.Dropout(0.2)self.fc1 = nn.Linear(32*53*53, 256)self.fc2 = nn.Linear(256, 84)self.fc3 = nn.Linear(84, 2)self.softmax = nn.LogSoftmax(dim=1) def forward(self, x):  
    # add sequence of convolutional and max pooling layers  
    x = self.pool(F.relu(self.conv1(x)))  
    x = self.pool(F.relu(self.conv2(x)))  
    x = self.dropout(x)  
    x = x.view(-1, 32 \* 53 \* 53)  
    x = F.relu(self.fc1(x))  
    x = self.dropout(F.relu(self.fc2(x)))  
    x = self.softmax(self.fc3(x))  
    return x # create a complete CNNmodel = Net() Model Architecture We’ll also need to initialise our loss function and an optimizer. Loss Function will help us in calculating the loss by comparing the prediction and original label. The optimizer will minimize the loss by updating the parameters of the model after every epoch. They can be initialised by: # Loss functioncriterion = torch.nn.CrossEntropyLoss() # Optimizeroptimizer = torch.optim.SGD(model.parameters(), lr = 0.003, momentum= 0.9) 3. Train the Model It’s time to train the model! Training a model requires us to follow some steps which are: **Clear the gradients of all optimized variables:**There could be gradients from previous batches, therefore it’s necessary to clear gradient after every epoch : This step computes the predicted outputs by passing inputs to the convolutional neural network model Forward pass **Calculate the loss:**As the model trains, the loss function calculates the loss after every epoch and then it is used by the optimizer. This step computes the gradient of the loss with respect to model parameters Backward pass: This performs a single optimization step/ parameter update for the model Optimization Update average training loss Following is the code for training the model ( ) it’s for a single epoch 4. Model Evaluation To evaluate the model, it should be changed from model.train() to model.eval() model.eval()# iterate over test datalen(test_loader)for data, target in test_loader:# move tensors to GPU if CUDA is availableif train_on_gpu:data, target = data.cuda(), target.cuda()# forward passoutput = model(data)# calculate the batch lossloss = criterion(output, target)# update test losstest_loss += loss.item()*data.size(0)# convert output probabilities to predicted class_, pred = torch.max(output, 1)# compare predictions to true labelcorrect_tensor = pred.eq(target.data.view_as(pred))correct = np.squeeze(correct_tensor.numpy()) if not train_on_gpu else np.squeeze(correct_tensor.cpu().numpy())# calculate test accuracy for each object classfor i in range(batch_size):label = target.data[i]class_correct[label] += correct[i].item()class_total[label] += 1 # average test losstest_loss = test_loss/len(test_loader.dataset)print('Test Loss: {:.6f}\n'.format(test_loss)) for i in range(2):if class_total[i] > 0:print('Test Accuracy of %5s: %2d%% (%2d/%2d)' % (classes[i], 100 * class_correct[i] / class_total[i],np.sum(class_correct[i]), np.sum(class_total[i])))else:print('Test Accuracy of %5s: N/A (no training examples)' % (classes[i])) print('\nTest Accuracy (Overall): %2d%% (%2d/%2d)' % (100. * np.sum(class_correct) / np.sum(class_total),np.sum(class_correct), np.sum(class_total))) After evaluation, we find the following result: Test Loss: 0.006558 Test Accuracy of     0: 99% (805/807)Test Accuracy of     1: 98% (910/921) Test Accuracy (Overall): 99% (1715/1728) The result that we got was using only 2 Convolutional Layers, though researchers are using deeper networks which can extract much more detailed features. Since this model has learned to extract facial features, this can be furhter used for facial recognition, in which you could train this face classifier on your own images and create facial recognition system using transfer learning. Also, editing few lines of code in this would generate another Image Classifier with right amount of data and labels. Possibilities are limitless, you just need to practice it and apply it on any problem you want! Happy Learning! GitHub Repo: https://github.com/jayrodge/Binary-Image-Classifier-PyTorch Let’s connect on LinkedIn! Learn more . about me

Binary Face Classifier using PyTorch

By Solutions Engineer Albert Sunwoo This post originally appeared on the Optimizely Blog. , Hacker Noon’s weekly sponsor, is the world’s leader in digital experience optimization, allowing businesses to dramatically drive up the value of their digital products, commerce, and campaigns through its best in class experimentation software platform. enables product development teams to accelerate innovation, lower the risk of new features, and drive up the return on investment from digital by up to 10X. Optimizely Optimizely Why this approach? Experiments using Optimizely X’s Full Stack SDKs are typically implemented by using conditionals in your codebase to decide between feature variations. As experiments progress and clear winners from experimentation emerge this conditional code can create , once competing variations are no longer needed. technical debt This method also creates dependencies between the variation conditions and experiment code since the if / else statements need to know the variation names in order to route the application to the appropriate code path. This can become a problem, and I’m often asked by Full Stack users, what the best practice is for developing experimentation code that doesn’t leave sections of irrelevant code inside business logic and allows for additional flexibility when introducing new feature variations. To achieve those goals, there are a few options to consider when implementing an experiment: Standard Implementation: In Business Logic Implement the feature variation and variation selection code within the business logic. Pros Easy to implement in the short term. Cons Creates technical debt within business logic. Creates a coupling between if / else conditions and experiment configurations. Alternative 1: Using the Factory Pattern Abstract the feature variation selection code into a Factory class using the . Factory Pattern Pros Experimentation logic is kept separate from business logic, minimizing technical debt. Cons Still coupled with experimentation configuration. Alternative 2: Factory Pattern Using Reflection Further abstract the variation code by using Reflection in the Factory class. Pros Experimentation logic is kept separate from business logic, minimizing technical debt. Generic enough to be reused across experiments, there is no direct coupling to variation names. Increases flexibility for adding or removing feature variations. Cons Reflection adds overhead, reducing performance. Not a feature available in all languages. Experiment Setup Let’s dig into each of these to see how each would look using a real world example. For instance let’s say we wanted to experiment with how we presented products to users with different sorting algorithms. Using this example we’d setup an experiment in Optimizely Full Stack that would look something like: Fig 1. Here we’re experimenting with three different sorting algorithms that prioritize products based on price, the category they’re in, and their alphabetical name. We’ll apply our three different implementation options to this sorting experiment. Standard Implementation: In Business Logic The sample code below is the Java example code presented if you start a new Java Full Stack experiment like the one shown above in Fig 1. //Business Logic//...Variation variation = this.optimizelyClient.activate(experimentName, userId); if(variation.is("CategoryProductSort")){CategoryComparator comparator = new CategoryComparator();Collections.sort(unSortedList, comparator);} else if(variation.is("NameProductSort")){NameComparator comparator = new NameComparator();Collections.sort(unSortedList, comparator);} else if(variation.is("PriceProductSort")){PriceComparator comparator = new PriceComparator();Collections.sort(unSortedList, comparator);} sort.sort(sampleProductList()); //Continue Business Logic//… Using this method, these conditionals are likely embedded directly into the business logic of the application. In addition, the if / else conditions are tied directly to the variation names we’ve established in our Full Stack experiment configuration. As the experiment progresses, one of the variations on how to sort will likely emerge as a clear winner leaving the other variations obsolete. Having to clean up the obsolete variations results in cruft code embedded directly in business logic, creating hard-to-remove technical debt. Over time this technical debt can build up contributing to a messy codebase. Feature Variables Before we talk about the alternatives, I’d like to take a moment to introduce . In Optimizely Full Stack you now have the ability to create Feature Flags which represent new or experimental functionality in your code. Included with Feature Flags are Feature Variables. With Variables, you can instrument Features with configurable components or parameters. Feature Management We will be using these variables for the Factory Pattern implementation examples, since they are a cleaner fit than using variation names and provide more flexibility for specifying the name of the sorting algorithm in a Factory Pattern implementation.. Using Feature Variables In the Factory class examples you will notice the line: String className = this.optimizelyClient.getFeatureVariableString(featureFlag, featureVariable, userId); That was used in the Standard Implementation example. Instead of the line: Variation variation = this.optimizelyClient.activate(experimentName, userId); The use of the getFeatureVariableString(), which is based on Feature Variables, instead of activate(), which is based on the variation name, will give us more flexibility in how we can specify which algorithm we use. This will come in handy as we get into our Factory class implementations. Feature Flag Setup Let’s look at how we’ve setup our Feature Flag for our sorting algorithm experiment: Fig 2. Feature Flag in an Experiment Used in an experiment the Feature Flag would then look like: Fig 3. We will be using the class_name variable to specify the sorting implementation to be used. You can see that the string data type used for the class_name variable allows us to use fully qualified class names which will be useful in our later examples. Alternative 1: Using the Factory Pattern As previously mentioned, an alternative to using the Standard Implementation would be to use the Factory Pattern. The factory pattern is one of the which is used to solve the problem of creating objects without having to specify the exact class of the object being created. This solution comes in handy when we’re trying to abstract conditional logic from business logic. “Gang of Four” design patterns For this section, we’re going to use Java to demonstrate how to use the Factory Pattern with experimentation. Most languages have their own particular manner of implementing the Factory Pattern which can then be used to apply a similar approach. Java Inheritance Example We first need to set the stage a bit for this section. Let’s say we have a simple set of objects that follow a basic object oriented inheritance scenario: Shape being the parent interface or abstract class that sets the requirement of any child object having to know how to print itself. In an experimentation context the printSelf function would be the feature that is subject to experimentation or a controlled rollout. This kind of inheritance structure would be akin to a more real world example. For instance let’s revisit our product sorting example from before. Instead of implementing the various sorting algorithms all within the experiment conditionals, we could encapsulate each implementation in its own class which we could call when a user is placed in a variation associated to that algorithm. In the diagram above we see different sorting algorithm implementations encapsulated in child classes of sort. Using the sorting example, let’s see how an application can take advantage of this encapsulation and inheritance structure: The following code excerpt is using an OptimizelyFactory class to get only the version of Sort that’s relevant to the variation of the experiment. OptimizelyFactory optimizely = new OptimizelyFactory(dataFile);//...//...Sort sortingAlgorithm = optimizelyFactory.getExperimentImpl(“ProductSort”, userId);sort.sort(sampleProductList()); Using the Standard Implementation, at this point you would receive a variation object from the activate method, which you would then need to use conditionals to settle on a variation code path. However, with the Factory Pattern, all you need to do is rely on the Factory class to deliver the appropriate implementation to you. Moving the burden of the variation conditionals to the Factory class, and away from the business logic. Improving the overall cleanliness and maintainability of your code. Implementing the Factory Pattern Let’s take a look at the getExperimentImpl method in OptimizelyFactory and see how this is done: public ProductSort getExperimentImpl(String experimentName, String userId){Variation variation = this.optimizelyClient.activate(experimentName, userId); ProductSort retobj = null; if(variation.getKey().equals("PriceProductSort")){retobj = new CategoryProductSort();} else if(variation.getKey().equals("NameProductSort")){retobj = new NameProductSort();} else if(variation.getKey().equals("CategoryProductSort")){retobj = new PriceProductSort();} else{//Defaulting to price sortingretobj = new PriceProductSort();} return retobj;} The getExperimentImpl method uses the previously mentioned getFeatureVariableString() method to get the name of the sorting algorithm to be used (in this example the fully qualified class name did not need to be used, we just used it for consistency with the other examples). You can see that it takes the burden of creating the implementation object away from the main application code. So the logic of creating separate code paths based on the variation a user is in, is abstracted away in the factory classes and the sorting child classes. Looking back to our experiment setup in Fig 1. You’ll see the Factory class has corresponding values for the experiment name and the class names. This still creates the coupling between the if / else conditions and the experiment configuration but the conditions have now been removed from the business logic making the conditionals easier to remove once the experiment is over. Alternative 2: Factory Pattern Using Reflection is a feature of some object oriented programming languages that allows for inspection and instantiation of objects at runtime without having to know about their classes at compile time. This can be very useful when developing experimentation code. Reflection Since the names of classes that a factory creates don’t have to be known at compile time, the experimentation Factory class can use the values of Optimizely Feature Variables to identify and instantiate objects for its clients. This decouples the factory class code from the experiment configuration, and allows the Factory class to remain generic enough to the point where a Factory class needs no knowledge of the experiment implementations at all. Allowing us to use the same Factory class for any inheritance based experiment. Reflection Resources: Reflection Wikipedia Java Reflection Tutorial public T getExperimentImpl(String experimentName, String userId){Variation variation = this.optimizelyClient.activate(experimentName, userId); T retobj = null;try {String className = this.packageName + "." + variation.getKey();Class cls = Class.forName(className); Class partypes\[\] = new Class\[0\];  
   Constructor ct = cls.getConstructor(partypes);  
   retobj = (T)ct.newInstance(); }catch (Throwable e) {System.err.println(e);e.printStackTrace();return null;}return retobj;} The version of getExperimentImpl above uses the variables specified in Fig 3 and Java reflection to create the implementation objects. The value from getFeatureVariableString() is used to determine which child class of Sort needs to be instantiated. It should be noted that generics are used here so any parent class can be used. For the case of Sort we initialize the generic type when we create an instance of the OptimizelyReflectionFactory class. OptimizelyReflectionFactory<ProductSort> optimizely = new OptimizelyReflectionFactory<ProductSort>();//…//…ProductSort sort = optimizely.getExperimentImpl(“ProductSort”, input);sort.sort(sampleProductList()); Reflection Performance While the performance of Java reflection has improved over the years, it is important to note that reflection still does come at a performance cost in exchange for the abstraction convenience. If performance considerations are paramount above convenience in your experimentation use cases, you should likely go with the conditional based Factory class presented earlier. Other Languages Reflection isn’t common across all languages, so you may not be able to automatically tie variation names/variables to class instantiations. However, the factory pattern can be implemented in any language. This allows us to take use the same approach anywhere the factory pattern can be used. For factory pattern examples in other languages take a look at: Node Factory Pattern Python Factory Pattern Github For the full source code of both factory implementations, check it out on ! Github This post originally appeared on the Optimizely Blog. , Hacker Noon’s weekly sponsor, is the world’s leader in digital experience optimization, allowing businesses to dramatically drive up the value of their digital products, commerce, and campaigns through its best in class experimentation software platform. enables product development teams to accelerate innovation, lower the risk of new features, and drive up the return on investment from digital by up to 10X. Optimizely Optimizely

How the Factory Pattern Can Reduce Technical Debt

How I Coded Everyday for 365 Days

How New Technology is Transforming Teaching & Learning Changing the way we teach and learn is difficult. But, last week I realized how education is being radically disrupted by new technologies. Not all of my colleagues agree. And I have to admit that if you are active as a teacher or interested in education, you might think that education hasn’t changed much over the last few decades. Of course, we are all making more use of digital technology. But many people think the “essence” of teaching (transferring knowledge, information and skills) hasn’t dramatically changed. This is a mistake. Things are already different. In a digital age, education is less about students acquiring knowledge. Instead, the classroom of the future focuses on offering an experience that builds the capacity for living and working in a world of artificial intelligence, connected machines and automation. And such an experience can only be “successful” if it spurs curiosity, unleashes creativity, and demands teamwork. No doubt, accepting and embracing this change can be a little frightening. But, it also makes me feel excited and invigorated. Here then are three takeaways from last week’s events New Ethos First, my wife found an op-ed piece in the local newspaper on the need for education reform. The article was about how many schools in the region aren’t paying enough attention to new and disruptive technologies. At least, new and disruptive technologies are not being integrated into the curriculum in the “right way”. The key point? Schools are still preparing students for the old world. This not only hurts the students. It is bad for everyone. We need to have a better understanding of new technologies and their possible application. This is the only way to ensure that we are preparing young people for the future. Of course, new technologies have been introduced in school curriculums. Yet, the typical approach has been a conservative one, focusing on explaining rather than using technology. Instead, schools need to focus much more on offering a platform for understanding, experimenting and then co-creating with technology. “Hands-on” engagement in small teams is the best way of inspiring the younger generation and showing them that innovation is important and fun. The fact that a rather “conventional”, local newspaper pays attention to the tech makeover of the school curriculum convinced me that the way we are thinking about education has really changed. The pressure to embrace this new ethos is irreversible. New Content The second event was a discussion amongst my colleagues about teaching materials and assignments appearing on file share sites, such as . Course Hero Some colleagues were upset that their course materials and assignments were being uploaded without permission. They argued that students are prohibited from posting any materials unless they have the express consent of the teacher and the school. Several teachers suggested that students should be sent a warning that file sharing is an infringement of school rules and uploading of such materials will be disciplined. The question is whether this is the right approach for a digital age. Of course, I understand the copyright issues with sharing such materials. But compare this trend of “content sharing” with the music industry and the disruption that introduced in 1999. Educators can try to delay the use of “open source” teaching materials, but change is inevitable. Napster Instead, it may be smarter to embrace the idea of “content sharing”. A more open approach to “information” is already happening. There is a plethora of online resources that students can choose from to learn and understand particular topics. Think , and to name just a few open learning systems. It makes no sense to focus on “protected” knowledge-based content when such information is available from multiple online sources. Coursera EdX iTunesU If teaching is focused on new technologies and cultivating curiosity and creativity, then traditional materials are not a key differentiator anymore. It is the ability to “teach” students how to learn and work in a digital age that adds genuine value and not the ability to transfer information. In that respect, traditional “teaching materials” play a less important role in education. Classwork, as well as “exams” will take the form of “apprentice style group assignments” and competitive components will be more common in the classroom. Instead of traditional materials compiled by teachers, students will acquire much of the necessary information themselves from websites, blogs, online video or podcasts. This already appears to be the preference of most students these days. They prefer to collect information by themselves and at their own convenience. In this new world, teachers are no longer an authoritative source of “content”, but instead must focus on motivating and assisting students in making the best use of “content” that they find themselves. _Which TED Talks do students love? We asked TED-Ed Club Members around the world to share their favorites. Below, check…_blog.ed.ted.com 9 TED Talks recommended by students, for students New Style The third event was my participation at a conference on business organizations and innovation, where I attended a number of presentations by entrepreneurs and government officials. This might seem slightly remote from “teaching”, but this experience made me think about how the style of teaching needs to change and is already changing. The “best lectures” are becoming more like “TED talks”, in that they are concise, passionate and often controversial. A counter-intuitive effect of the current technological revolution is that it has made teaching much more “personal”. The use of personal stories in which challenges are confronted and overcome is the best way to attract attention and cultivate curiosity. Of course, examples and anecdotes have always been a great way of teaching. These examples have always been necessary to explain theories to students. But it is different now. This became very clear at my conference last week. The audience just switched off when presented with a traditional style lecture describing a new development or theory. Smartphones came out and “power naps” were taken. But when speakers framed their presentations around personal experience, everybody was engaged and involved in the discussion that followed. The audience wanted to learn (and augment their level of experience) from the successes and failures of the speakers. So, What’s Next? I hear more and more complaints about the current generation of students. My colleagues often grumble that “Millennial students” are lazy, unmotivated and overly-focused on convenience. They don’t prepare. They are always looking for “the easy way out”. They are constantly playing with their phones. This kind of complaint misses the point. If young people aren’t motivated they just lose interest. As educators, we need to think more about how to engage and inspire them. And no doubt this requires more disruption. But such disruption is already here. After all, new technologies are disrupting education in ways I could never have predicted even five years ago. And this disruption will create an education that is a better fit with the new digital world. Building the capacity for dealing with new technological opportunities and challenges is the only way to better prepare young people for the uncertainties of the future. Certainly, this change will put more pressure on teachers. They have to adapt materials more often and keep up to date with the latest trends in technology. New technological developments need to be addressed and incorporated into the curriculum. References to online resources have to be constantly reviewed and assignments renewed. But this is not a bad thing. Teachers need to become collaborators with the students. It spurs lifelong learning, which can only lead to more creativity and curiosity in the classroom. 👏 Thank you for reading! Please click and hold the below, or leave a comment. There is a new story every week. So if you follow me you won’t miss my latest insights about how the digital age is changing the way we live and work.

Education Disrupted (Finally)!

I did not really have any name for the architecture. But having a name will make it easier for us to remember it. So after some thought I thought it would be best to call it “Extensible Architecture”. That is because, it is basically an extension to MVC. We just added new design patterns and layers to bring shape to this architecture. Extensible Architecture Short descriptions: Domain specific code/Business logic eg. getFlightAvailability() [Domains]: Third party code/APIs separation. eg. Flight Booking API [Adapters w/ or w/o Interfaces]: : Common application/business logic goes here. eg. log() [Services] : Persistence logic goes here. eg. saveData() [Repositories] : Three basic layers of separation [MVC : Model, View, Controllers] Now let’s go for an in-depth understanding of each layer. Domains: Domains are classes that act as a glue to our various layers in the application. It contains all our domain/business logic. It directs what API we need to call and where we need to save our data. In our flight application code in Part 1 of our series, we had all our domain code in the “getFlightAvailability” method of the Controller. All those belong instead in a domain layer, which we call as a domain. There are no interfaces here, just plain old php classes. Adapters: Adapter is actually a design pattern. It is a special class that is used as a bridge between two different interfaces. We usually use an Interface class which the Adapter class will adhere to. But I say this is not required in all cases. If you are not sure if the API is going to be a fit, you can always write an Interface for it. I usually do not see any need for extra layer of Interfaces even for Adapters. Services: Services are one of the most overused terms in PHP community. People use it for various reasons, and there is no clear definition of the term due to that. For me Services are application logic that usually are cross-referenced from different domain classes. It can also be domain logic that is too big for the domain itself. If some domain logic needs to be cross-referenced from different classes, then that usually is separated to its own Service class.You could further subdivide them into Application Services and Domain Services if needed. But in a medium sized app, I think they can co-exist under the same umbrella “Services”. Keep in mind, we are not talking about Laravel Service Providers here. They are completely different beasts. They are services which are used by the framework itself, or that are needed globally throughout the application. Repositories: A repository is the persistence layer that retrieves and stores data. It usually retrieves them from the ‘Model’ which is the Eloquent Model in Laravel. Repositories are essential to keep all the persistence logic out of our main Domain layer. They help act as a bridge between our internal code and the Model. This way no SQL or Eloquent queries can creep in to our business logic. It also makes easy to switch our persistence layer, we would just rewrite our repository instead of having to touch our domain layer. Now, I am not advocating that we should never allow anyone to write their business logic in a controller. If a feature is small, by all means go ahead and write them in a controller. You can also directly reference your Model there, if the db call is just one liner. Just keep in mind that, if ever you need to change the persistence layer, you would need to refactor it into a Repository. The main point behind our simple architecture is to be quick and only refactor when it is actually needed. And further, only refactor the part you need to change. Also these layers are not all you can add. If you need an extra layer between your View and your Repository/Model, you can use a pattern. In Clean Architecture by Uncle Bob, he uses a similar pattern called ViewModel. You can use that to do all the decorating logic before you pass it to a view. Decorator Another layer that has been useful for me is the layer. It sits before the Adapter layer. It processes the data that comes through an external API, then it passes it to the Adapter. Translators do manual conversion from XML/JSON structure to native objects. In case of PHP that would be plain native PHP objects. Translator Flowchart view of Extensible Architecture In an application where there are two or more than two user facing interfaces, let’s say front-end and back-end, we can share the services, adapters and repositories. The flowchart above shows us the overview. Anyways, this is it for Part 3. We will finally refactor the code we wrote in the first part, next. We will use our Extensible Architecture for that purpose. Please don’t forget to give a clap, on this article. And I’ll see you in the next part. :) Link to Part 4: https://medium.com/@sameernyaupane/php-software-architecture-part-4-refactoring-fd577eb6fe3f

PHP Software Architecture Part 3: Extensible Architecture

A Layman’s Guide To An Old & Disruptive Technology This article introduces readers to the basics of Cryptography, its origins, present state and possible future. An old technology is changing the ownership of trust, by systematic disinter-mediation, from mainstream institutions to networks. An idea, that some believe, is too futuristic for the times we live in but could very well be a reality. In any case, developers — the architects of the modern world have started using Cryptography to create new currencies and tokens, upend existing ones and more importantly taking aim at redefining the world of finance and our notions of money in the process. If this isn’t a revolution, I don’t know how else to characterize it. This article is ultimately meant to explain the basic technology behind cryptocurrencies such as Bitcoin and tokens such as Ethereum. Bear in mind — as per the latest SEC ruling, tokens are securities and not currencies so Ether (token) should not be confused with Bitcoin (currency) Every once in a while, a new technology, an old problem, and a big idea turn into an innovation — Dean Kamen, Inventor Necessity Is the Mother of Invention For a word having to do with secrets, "cryptography" has a surprisingly transparent etymology. The word traces back to the Greek roots meaning "hidden," and meaning "to write." (Merriam Webster Dictionary) kryptos, graphein, If the first thing that comes to your mind when you think of Cryptography is hieroglyphics, your word association qualities are very good. Earliest form of cryptography was in the form of Hieroglyphs (inscriptions on a tomb from the Old Kingdom of Egypt circa 1900 BCE). As is understood today, hieroglyphics were more a dignified work of art than a code or cipher. The plot thickens between 2nd century BCE and 3rd century CE when the the science of politics) is a brilliant Indian treatise on military strategy, economics and urban planning, composed by Kautilya. The Arthashastra mentions the use of spy networks and mentions giving tasks to spies in secret code. Arthashastra, ( In 100BC , Julius Caesar was known to use a form of encryption to convey secret messages to his army generals posted in the war front. This is the most well known cipher which was known as a substitution cipher where each character of the alphabet was shifted by 3. So, A became D, B became E etc. So, the word BALL would become EDOO and so on. The “key” to solving this puzzle was obviously shifting the alphabet by 3. Subsequently, the methods changed from first cryptanalytic techniques developed by the Arabs, progressed to polyalphabetic ciphers developed by (father of modern cryptology) around the year AD 1467 to the mechanical and electromechanical which were in wide use in World War II. The most famous being the German Enigma machine which was cracked by Polish and subsequently British team of chess masters and mathematics dons such as , , and (the conceptual founder of modern ). Leon Battista Alberti cipher machines Gordon Welchman Max Newman Alan Turing computing The Wonder Years Do You know or remember the feeling when you fall in love for the first time in a nerdy way. I experienced that emotion when I got my hands on my first Intel Pentium IV powered PC (Personal Computer) in 1997. About 6 years ago, Phil Zimmerman created an encryption software called ‘Pretty Good Privacy’ (PGP) which was used to encrypt email, text files, disks etc. PGP turned out to be my first brush with user friendly Cryptography. The software was very simple to use but the underlying technologies ie a serial combination of hashing, data compression, symmetric-key cryptography, and finally public-key cryptography was complex with each step using one of several supported algorithms. Symmetric , Asymmetric Cryptography and Hashing Symmetric cryptography uses one key e.g. Julius Caesars ‘3' key cipher was an example of symmetric Cryptography. Understandably, symmetric Cryptography was not too secure. Enter asymmetric or public key Cryptography.The illustration below explains the concepts above in one picture: computer-trickster.blogspot.tw/2015/11/encryption.html?m=1 A Brave, New World Modern crypto currencies such as Bitcoin are based on 2 technologies: A. Public Key Cryptography/Asymmetric Cryptography Let’s say Alice wants to send Bob a message. 1. She signs it using her private key which proves that she originated the message. 2. Alice also uses Bob’s public key to encrypt the message. 3. To decrypt the message, Bob has to use his private key. Therefore, only Bob who owns his private key can open the message. B. Hash Functions SHA-2 ( ) is a set of designed by the United States Secure Hash Algorithm 2 cryptographic hash functions National Security Agency (NSA) Hashcash uses symmetric cryptography ie a one way key to create a hash (explained in a crude way — jumble/gobbledygook) out of the input data. Let’s say the data consists of the name Ada. Using a one way key, this data is hashed(jumbled) into 000CFC. The ooo attached ahead of the letters CFC are known in technical terms as ‘Nonce’. In the English language, a Nonce word is a word used for a one time meaning (use once, nonsense otherwise). It is useless otherwise. Example of a nonce word is ‘Wug’ which doesn’t have any meaning except for teaching children. In case of Bitcoin, a nonce is a string of zeros placed before the input data to create a unique hash(jumble) of data. Bitcoin mining therefore is the use of brute force combinations to find the hash ‘000CFC’. The person who finds this value (using his electricity and computer) is the one who possesses the golden nonce and is rewarded with 25 bitcoins. However, this is a very simplistic example. The data or message is usually hashed using a Merkle Tree: In a Merkle tree, each non-leaf node, for example the second layer above is labeled with hash value of the child node (layer 1) in this example. Finally, this tree results in what is called a root hash. This root hash is then combined with a nonce and the previous block all the way up to the first block in the chain to form a Blockchain: Bitcoin, therefore is not a currency but rather a reward given to people who use their _computers (CPU’s followed by Graphics Processing Unit (GPU) chips and now APplication Specific Integrated Circuits (ASIC) chips) t_o solve the Cryptographic puzzle and therefore show ‘proof of work’ done to record a transaction in the Blockchain ledger. Very soon, we may witness cryptography. quantum Macro Lessons for Entrepreneurs Adopting a macro view, the application of Cryptography is the application of an old idea (now enabled by advances in machines and computing) to new problems. Although, the world may not be ready for the idea of crypto currencies just yet. recently published an article titled “ . The crux of this article was that quant hedge funds are searching for new avenues ie information sources to generate superior returns (alpha). This is because of the fact that in this age of big data, where each byte of publicly available data is quickly processed by markets i.e. The alpha is arbitraged away and it’s becoming harder to find new sources of information to generate higher returns. Bloomberg Quants are clamoring for data, causing soul searching at large banks” Similarly, entrepreneurs maybe facing the same dilemma i.e. The market may not be ready for the product yet or in the words of Patrick Collison, CEO, , it maybe increasingly difficult to find a niche market that is under served. In such cases, it’s important to ask a few questions: Stripe 1. Is it the right time i.e. is the market ready for your product? Launching an idea before its time has come can prove detrimental. 2. Is the technology transportable to a different geography, market or client base which is ready or getting ready for the product? This would include regulation and availability of human capital. One of the most renowned economists — Dani Rodrik explains that transplanting manufacturing technologies to a different country is easy (eg Toyota manufacturing cars), agricultural technologies are hard to transplant because of differences in soil and weather and so is the case with services. 3. Is there a different application of the product that can be created by changing the features of the product or adding new features? In the end, it takes pretty good cryptography to illuminate a larger trend — technology reengineering the real world. Final Thoughts Since my first PC in 1997 and consequently, my first brush with cryptography ie using Pretty Good Privacy (PGP), I am amazed by the rapidity of change. I could not have thought that in two decades, the technology in a piece of software that was used to secure my emails could one day end up challenging the very concept of money and fiat currencies in its wake. In other words, I could not imagine a future where technology becomes finance and computer code becomes currency. The lesson for us is that this pace of change is here to stay and observing the trends in technology is nothing short of witnessing a revolution- one that I am very sure will upend our lives and change the way we work and live. With debates around privacy of our data and AI, it is exciting and terrifying at the same time. Therefore, my request to everyone is to learn as much about technology as you can (including but not limited to taking formal classwork on data science). Our intuition about the future is linear. But the reality of information technology is exponential, and that makes a profound difference. If I take 30 steps linearly, I get to 30. If I take 30 steps exponentially, I get to a billion- Ray Kurzweil My Intentions are not to scare you. Rather, it is quite the opposite. I am trying to simplify the jargon so that technology becomes more human, fun and understandable. I don’t know whether I am succeeding but to me, trying is half the battle won. Thank you for reading. If you think this article is educational, please share it with your followers on Facebook, Twitter, LinkedIn or other social media. You can follow me on Twitter: @akothari_mba If you liked this article, please recommend it by clicking the heart below.

Pretty Good Cryptography

article This originally appeared on dormoshe.io Decorators are one of my favorite features in ECMAScript. The ease of use and easy to build make them so popular. They are clean. They are simple. They are cool. They are here to stay. Now you can use them, and you don’t want to ignore them. Most of the developers use decorators, but they don’t know what they are and how to build them. The first time I really met the decorators was when , in September 2016 — do you remember? 😍. They look at me, I look on them and it was love at first sight. Angular 2 was landed In this article, we will understand what they are, how to build them and why we don’t need to be afraid of them. We will see how to build the . rich logger decorators from my previous article One moment, what is a Decorator? A decorator is just a function. Decorators make it possible to annotate and modify classes and properties at design time. A Decorator is a special kind of declaration that can be attached to a class declaration, method, property, or parameter. Decorators use the form @expression, where expression must evaluate to a function that will be called at run-time with information about the decorated declaration. Case Study In this section we will see how to build some parts of the project. rich-logger-decorator Logger Decorator The @ decorator is a method decorator. Log messages will be printed before the function will start and after the function will end. This decorator can get options that define the behavior of the flow. Logger Full logger decorator code Because of the options argument, this decorator needs to return a function (so this is a decorator factory). A decorator has a signature like that . method function(target, methodName, descriptor) It takes 3 arguments: — the original method being decorated. target — the name of the method being decorated. methodName — a property descriptor of the given property if it exists on the object, undefined otherwise. The property descriptor is obtained by invoking the function. descriptor Object.getOwnPropertyDescriptor() The first part of the function tries to fetch the descriptor, for some edge cases (for the decorator): ClassLogger Logger decorator code — part I The second part is the fetching of the original method by accessing the value of the descriptor: Logger decorator code — part II The third part is the monkey patch of the original method: Logger decorator code — part III As you can see one message is being logged by the mechanism before the original method call and one after the call. The function called with the source arguments call and the result returned by the new method. In the last part, we mark the method as monkey patched method (will be used later in the decorator) and return the descriptor to support using of more decorators for this method. ClassLogger Logger decorator code — part IV @ClassLogger The decorator is a method decorator. When you put the decorator on top of the class definition, all the methods in the class are logged automatically (except methods that are decorated by ). @ClassLogger @DisableLogger Full class logger decorator code As Logger decorator, this is also a decorator factory. A decorator has a signature like that . The target is a reference to the class constructor. class function(target) The decorator needs to decorate the requested methods — all the class methods being decorated, unless the array option will be set. After it’s set — only the methods in the array will be decorated. loggedMethodsNames Full class logger decorator code — part I This code fetches the properties of the class (including the class methods). Then they were filtered using the array option. loggedMethodsNames Full class logger decorator code — part II Now, loop over the filtered items. If the item is not a function or its already decorated by the logging mechanism (according to ), the item is omitted. __loggerMonkeyPatchCompleted Full class logger decorator code — part III And now we “monkey patched” these methods like in the method Logger decorator. That’s it. @DisableLogger The decorator is also a method decorator. The decorator will skip this method from being logged. @DisableLogger ClassLogger Disable logger decorator code For this purpose, we just need to change the boolean value and that’s it. This is an example for a simple decorator that doesn’t change the original method. References article Rich Typescript Logger Decorators for Easy Coding GitHub repository rich-logger-decorator in npm rich-logger-decorator Conclusion Decorators are amazing. They improve readability and reusability. You can compile them to ES5 with Typescript, Traceur or Bable. And now you know how to build them, so go and code your custom decorators and don’t forget to share… You can follow me on dormoshe.io or Twitter to read more about Angular, JavaScript and web development.

All You Need to Know About @Decorators— a Case Study

article This originally appeared on dormoshe.io How much time do you waste on writing logs for your functions? How many times do you change your function name and forget to change the name in the log message? How many time do you find yourself regretting that you didn’t add a log for knowing if the function was called? regrets, forgets, wasting time — just use the magical Typescript feature — Decorators. NO MORE NO MORE NO MORE In this article, we will review the rich logger decorators and their cool options. In the near future, I will publish another article in order to explain how to build decorators like these. TL;DR You can find the decorators in my GitHub and use them via . If you have further improvements, please make a pull request. repository npm Installation npm i rich-logger-decorator Basic usage In this example, we will use only the decorator in order to log all the class methods. ClassLogger Basic example And the console looks like: Basic example output Mixed decorators and options In this example, we use the and decorators with the default options and the decorator with custom options. ClassLogger DiableMethodLogger MethodLogger Mixed example And the console looks like: Mixed example output @Logger decorator The Logger is the main decorator. If we want to be precise, this is a decorator factory because this function is getting an argument and returns a function, but it is not the subject. The Logger decorator needs to be on top of the function you want to log. The log messages will be printed before the function will start and after the function will end. This decorator can get options which define the behavior of the flow and, eventually, affecting the log messages. When the options do not supply, the defaultFunctionLoggerOptions object is used by the decorator. The options are defined by the FunctionLoggerOptions interface. FunctionLoggerOptions This is the interface of the Logger decorator options argument. Function logger options interface As you can see the interface contains some properties. — this property can be boolean or array of strings. When the value is , the arguments and their values will not be a part of the log message. When the value is , all the argument and their values will be a part of the log message. When the value is an , the arguments, that their names contained in the array, will be a part of the log message. withArgs false true array of strings — when the value is true, the time will be a part of the log message. withTime — when the value is and the function is a method of a class, the class properties, and their values will be part of the log message. This option can be also an of the class (will behave like , just for class properties). withClassProperties true array of the properties names _withArgs_ —a function that replaces the traditional . This function will be called with the log message at the start and the end of the original function. logFunction console.info — a function that gets the resulted string of the decorator flow and logs the customized message. This function gets the time, class name (if exist), function name, start/end log, strings array of the arguments and their values and strings array of the class properties and their values. formatAndLogFunction All of the options are optional. DefaultFunctionLoggerOptions defaultFunctionLoggerOptions is an object with default values for LoggerOptions. The default values are: — true withArgs — true withTime — false withClassProperties — the console.info function logFunction —no default value. When the value doesn’t exist, the default behavior happened. formatAndLogFunction @ClassLogger decorator The used by classes. When you put the decorator on top of the class definition, all the methods in the class are logged automatically. This is so convenient to put the decorator and watch the magic happened. ClassLogger As the decorator, the decorator can get options which define the behavior of the flow and eventually affects the log messages.When the options do not supply, the used by the decorator. The options are defined by the interface. Logger defaultClassLoggerOptions ClassLoggerOptions ClassLoggerOptions This is the interface of the decorator options argument. ClassLogger Class logger options interface As you can see the interface contains some properties. —the options for the methods of the decorated class. Same as the options of the Logger function decorator. methodOptions — array of method’s names that being logged. When the option is undefined, all the class methods are logged. loggedMethodsNames All of the options are optional. DefaultClassLoggerOptions is an object with default values for . The default values are: defaultClassLoggerOptions ClassLoggerOptions —same as of the function decorator. methodOptions defaultLoggerOptions — undefined (so all the class methods will be logged) loggedMethodsNames Additional decorators For more convienient usage we will see two more decorators that make our life easier. @DisableLogger decorator When you are using the decorator (without the methods array option), all the class methods will be logged. In order to disable specific method for being logged, you can put the decorator before the method definition. This is a clearer way to prevent the logger behavior than the method array option, because of the second one restricts us to write the method name in the array. ClassLogger DisableLogger @LoggerWithoutArgs decorator This decorator is a syntactic sugar of the Logger decorator with option of false. Namely, the argument and their values will not be part of the log message. If other options will be provided, the decorator will use them, except for the option. withArgs withArgs Conclusion The decorators are available to use via the npm package. From now on, the logging feature is easy to use than ever. All you need is to use the rich-logger-decorator and that’s it. You can configure the decorator with the options and just coding… rich-logger-decorator The next part of the article can be found . here You can follow me on dormoshe.io or Twitter to read more about Angular, JavaScript and web development.

Rich Typescript Logger Decorators for Easy Coding

In my opinion, the most complex rules in the C++ have to do with the ordering of templates and class template specializations. They are dense, difficult to follow, underspecified, involve jumping from section to section in the standard, and, on top of all of that, the major compilers don’t even agree with the standard anyway. Let’s explore what I mean. language function When doing overload resolution, there’s a lot of steps we go through to determine which function to actually call. We rank different kinds of conversions, we prefer some kinds of references to others, we prefer non-templates to templates, all in careful order. The very last tie-breaker, before we give up and consider the call ambiguous, is to determine if one function template is than another. A simple example: more specialized Obviously, #2 is more specialized, since pointer types are a strict subset of all types. That’s all well and good that we can figure this out — but what do the rules say about how the compiler is supposed to reason about this? The process is, roughly, the compiler synthesizes new types for each template parameter of one function template and attempts to perform template deduction against the other function template. It then does this in the reverse order. If deduction succeeds in both directions, or neither direction, neither function template is more specialized than the other. If deduction only succeeds in one direction, then that is the reverse direction of specialization. In this simple example, we first attempt to deduce #1 from #2. We synthesize some new type, call it , and attempt to perform deduction: UniqueA Function: template <class T> void foo(T ); // #1Arguments: UniqueA* This deduction succeeds, with . Now, we do the reverse. We synthesize another new type, call it , and attempt to perform deduction: T=UniqueA* UniqueB Function: template <class T> void foo(T* ); // #2Arguments: UniqueB This deduction fails. is not a pointer type. Since deduction only succeeded in one direction, #2 → #1, that makes #2 the more specialized function template. This whole process answers our original question: which function do we call? #2. UniqueB It’s worth going through the entire process for a simple case, because we’re about to add a wrinkle that will tear our world apart: non-deduced contexts. We understand non-deduced contexts in the normal case of template deduction: template parameters in non-deduced contexts are not deduced (as the name may suggest!). Such parameters must either be provided explicitly or deduced from other arguments. If neither happens, deduction fails. In this example: Determining what happens is straightforward. #1 is a viable candidate, deduction succeeds with . In #2, appears only in a non-deduced context and is not provided. Hence, deduction fails. We only have one viable candidate, so we’re done. This calls #1. But what happens if we add a wrinkle: T=int T Now, candidates are viable, and both are exact matches. As before, we’re down to the final tiebreaker: partial ordering. Which function template is more specialized? Unlike the earlier case of vs , we don’t have any clear intuition here as to which should be more specialized. At least, I don’t. So let’s just follow the rules and find out. We start by synthesizing new types and perform deduction in both directions. Let’s start by deducing #1 from #2: both T T* Function: template <class T> void foo(T );Arguments: identity_t<UniqueA> Now, isn’t . It’s just some type. We don’t perform any instantiation in this context. We can think of this as some other unique type, call it . In this direction, deduction succeeds, with . What about the other direction: identity_t<UniqueA> UniqueA UniqueA' T=UniqueA' Function: template <class T> void foo(identity_t<T> );Arguments: UniqueB We have a non-deduced context, so deduction fails. Since deduction only succeeds in one direction, #2 → #1, #2 is considered the more specialized function template, so that’s the one that gets invoked. (In case there’s any doubt, every compiler agrees with this interpretation. ) Does this jibe with intuition? I’m not sure. Is a subset of types of ? But hold on Dorothy, this ride’s about to get more fun. Let’ s add another parameter. identity_t<T> T What if we add one more argument (I originally asked about this example on ): StackOverflow Here, even though is a non-deduced context in the second parameter of #2, it’s deduced from the first parameter as , so deduction succeeds without having to explicitly provide anything. How’s our intuition going to work for here? If is more specialized than , then surely specialization should work under composition and should be more specialized than ? Well, intuition is overrated, let’s do the work. T int identity_t<T> T (T, identity_t<T>) (T,T) Let’s deduce #1 from #2: Function: template <class T> void foo(T, T);Arguments: UniqueA, identity_t<UniqueA> (or UniqueA, UniqueA') This deduction fails, we deduce two different types for : and . What about the other direction? T UniqueA UniqueA' Function: template <class T> void foo(T, identity_t<T> );Arguments: UniqueB, UniqueB Deduction succeeds in the first argument, but what do we actually do in the second? What do we do in partial ordering when the parameter is a non-deduced context? The only guidance the standard gives us is in [temp.deduct.partial]: In most cases, all template parameters must have values in order for deduction to succeed, but for partial ordering purposes a template parameter may remain without a value provided it is not used in the types being used for partial ordering. A template parameter used in a non-deduced context is considered used. [ Note: — end note ] [ Example: template <class T>          T f(int); // #1template <class T, class U> T f(U);   // #2 void g() {f<int>(1); // calls #1} — end example ] What does that mean? is a non-deduced context in #2, so in partial ordering, we could deduce but we can’t deduce . This point indicates that even though we can’t deduce , we just consider that we could. Template parameters appearing only in non-deduced contexts count as if they were deduced. I think. Maybe. T U=int T T This means, in our original example, that deduction succeeds #1 → #2 (we ignore the non-deduced context) but not #2 → #1 (we deduce different types for ), so we call #1: the function, which is the opposite of what my intuition would have suggested. But here we also have our first divergence: while gcc, clang, and icc all agree that #1 is more specialized, MSVC considers the call ambiguous. Does that make MSVC wrong? I don’t actually know. Interestingly, MSVC does consider the quoted standard example to be ambiguous. Why the difference in reasoning? T (T,T) not Let’s add another wrinkle on top of this old man skin. Class template partial specialization. How do we pick which class template partial specialization to use? We use the partial ordering rules. From [temp.class.order]: For two class template partial specializations, the first is more specialized than the second if, given the following rewrite to two function templates, the first function template is more specialized than the second according to the ordering rules for function templates (14.5.6.2): (1.1) — Each of the two function templates has the same template parameters as the corresponding partial specialization. (1.2) — Each function template has a single function parameter whose type is a class template specialization where the template arguments are the corresponding template parameters from the function template for each template argument in the template-argument-list of the simple-template-id of the partial specialization. Consider this example (which I also originally asked about on ): StackOverflow is a popular way to write type traits, so seems appropriate to feature it in this post somehow. To answer the question of what this program prints, we have to know which specialization of is chosen. And, as specified, that question is answered by determining which of these function is most specialized by the partial ordering rules: void_t A Comparing #1 to #2 and #3, it’s clear that we can deduce #2 → #1 and #3 → #1 but not the reverse, so it’s between #2 and #3. Let’s try #3 → #2: Function: template <class T> void foo(A<T, void_t<T>> ); // #2Arguments: A<UniqueA*, void> This succeeds. We can match from the first parameter and then, as before, we ignore the non-deduced context. And #2 → #3: T=UniqueA* Function: template <class T> void foo(A<T*, void> ); // #3Arguments: A<UniqueB, void_t<UniqueB>> This fails. is not (despite what the name and Walter Brown may tell you!) Since deduction only succeeds in one direction, great! #3 is the most specialized. We also have compiler unity on this: gcc, clang, icc, and MSVC all agree: #3 is the most specialized function here. void_t<UniqueB> void So back to the original question. What does yield? It obviously yields 2 right, we just went through the process of determining this, all the compiler agreed with us! A<int*, void>::value Wrong. Every compiler consider this an ambiguous specialization between #2 and #3. This, to me, is quite baffling. The rule expressed in the standard is clear: the most specialized class template specialization is the one that gives the most specialized synthesized function template. All the compilers agree that #3 meets the bill for the latter, and yet they don’t agree that #3 is the most specialized class template specialization. This is a fascinating bit of compiler unity. I’m always hesitant to file a compiler bug even when I find one. But usually there’s there’s one compiler that’s right and one that’s wrong, I don’t even know what to do in this case. File bugs for everybody? How did this situation even arise? Ultimately, this seems like a problem of underspecification. It would be nice if the standard gave more clarity on this subject. What do we actually do with non-deduced contexts in partial ordering? Especially as and similar tools are used more commonly in code, it’s important to have clear guidance on what the code is actually supposed to do. SFINAE isn’t even well defined in class specializations and yet it’s prolific in it’s use there. void_t Regardless, there’s one thing that’s abundantly clear: C++ is really complicated.

Stories, News & Mentions about CLASSYORG

Classyorg’s Stories on HackerNoon