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

Stories, News & Mentions about CLASSYORG

Classyorg’s Stories on HackerNoon