[This article is part of YakiHonne Explore2Earn. Click to earn more Sats"! ](https://www.yakihonne.com/article/naddr1qq2457f4wvk4vhm4vdskv3jpdf5xkaz3feh8sq3qyzvxlwp7wawed5vgefwfmugvumtp8c8t0etk3g8sky4n0ndvyxesxpqqqp65wqfg09z)

![image](https://s.yimg.com/ny/api/res/1.2/K4yJF7H.F1vaweX46iF2rA--/YXBwaWQ9aGlnaGxhbmRlcjt3PTk2MDtoPTUzOTtjZj13ZWJw/https://media.zenfs.com/en/newsfile_64/78e33cafc5eacbdc86044f15874eb1c9)

We are happy to announce Oraichain is partnering with DoraHacks to advance the adoption of its Layer 1 ecosystem for AI and Data economy. Over the coming months, our teams will work together on a number of initiatives to support the next generation of AI + blockchain innovations, including AI-enhanced dApps, AI Oracles and key infrastructure.

DoraHacks is a global hacker movement and the world’s most active multi-chain Web3 developer incentive platform. More than 3,000 projects from the DoraHacks community have received over $30 million in grants and hackathon prizes. DoraHacks.io has around 250,000 active users worldwide, with the platform offering hackathons, bounty, quadratic funding, privacy voting, and other resourceful community governance/funding toolkits. Oraichain is proud to partner with DoraHacks to attract talent and support new projects on the network, joining the ranks of 80+ major Web3 ecosystems currently using Dora infrastructures to successfully fund their open-source communities.

With the vision of becoming the essential hub for AI builders, Oraichain’s IBC enabled Layer 1 provides complete infrastructure for an open data economy, providing tools for data scientists to structure data, train, test and publish models to Oraichain’s AI Oracle and monetize with maximum transparency and inclusivity. With this partnership, both teams aim to foster innovations in blockchain and AI, leading to the creation of AI-enhanced dApps on Oraichain and AI Oracle services compatible with smart contracts on many networks.

To advance the adoption of this AI Layer 1 for the data economy, Oraichain and DoraHacks will work together to accomplish the following:

**Co-Hosted Hackathons**
Leveraging DoraHacks’ developer community and platform traffic, the core goal of this partnership is to promote Oraichain’s ecosystem, tech stack and toolkits to a wider audience, attracting BUIDLers from every corner of the world to innovate AI + blockchain use cases. DoraHacks will lend their expertise to organize virtual and in-person hackathon events, workshops and demo sessions with the goal of creating a rich and rewarding experience for all participants. In addition, both teams will work together to identify synergies with other major ecosystems, building relationships that can further expand Oraichain’s impact within the broader blockchain space.

Planning for the first co-hosted hackathon is currently underway. Details regarding date/time, registration, judges and prize pool will be announced in the near future. We look forward to this event with great anticipation, excited to recognize and reward the most promising innovations in AI x Web3. Stay tuned.

**DoraHacks Node**

In addition to providing support for upcoming hackathons, DoraHacks will also join Oraichain mainnet as a validator, actively participating to secure the network. This action reinforces long term commitment and mutual confidence for both parties, and to support, the Oraichain Foundation will initially delegate 50,000 ORAI to bootstrap DoraHacks’ node.

**Join Us**
This is a very exciting time for the Oraichain ecosystem. We look forward to welcoming hundreds of new developers and projects over the coming year, working with DoraHacks to streamline onboarding and fund promising use cases. As the relationship deepens, we are committed to exploring the many ways DoraHacks and Oraichain can work together to support talented developers. If you are interested in learning more about Oraichain and exploring AI x Web3 technologies, we invite you to join our community!

**About Oraichain**
Oraichain is the world’s first AI-powered oracle and ecosystem for blockchains. Beyond data oracles, Oraichain aims to become the first AI Layer 1 in the Blockchain sphere with a complete AI ecosystem, serving as a foundational layer for the creation of a new generation of smart contracts and Dapps. With AI as the cornerstone, Oraichain has developed many essential and innovative products and services including AI price feeds, fully on-chain VRF, Data Hub, AI Marketplace with 100+ AI APIs, AI-based NFT generation and NFT copyright protection, Royalty Protocol, AI-powered Yield Aggregator Platform, and Cosmwasm IDE.

Exclusively authorized by DoraHacks, please indicate from[ yakihonne.com](yakihonne.com) when reprinting

2023 Mar. Partnership Announcement: Oraichain X DoraHacks


I want to join the Buidlers monthly magazine creation activity — This is a comment on: https://yakihonne.com/article/naddr1qq2kucmt89n4wvjfx4rryd6l94n565jhxf8ksq3qyzvxlwp7wawed5vgefwfmugvumtp8c8t0etk3g8sky4n0ndvyxesxpqqqp65wnkefak


[This article is part of YakiHonne Explore2Earn. Click to earn more Sats"! ](https://www.yakihonne.com/article/naddr1qq2457f4wvk4vhm4vdskv3jpdf5xkaz3feh8sq3qyzvxlwp7wawed5vgefwfmugvumtp8c8t0etk3g8sky4n0ndvyxesxpqqqp65wqfg09z)

![image](https://en.cryptonomist.ch/wp-content/uploads/2022/12/ton-crypto-1140x600.jpg.webp)

The TON crypto foundation, a non-profit association of developers and enthusiasts that exists to promote The Open Network (TON), has announced a global hackathon in collaboration with DoraHacks.

The latter is a leading global hacker organization that serves as a bridge, connecting hackers to business challenges and entrepreneurial ideas. The Open Network (TON) is a revolutionary technology to unite all blockchains and Internet Web2 into a single open network.

TON’s layer 1 architecture is designed to scale up to 2 to the power of 32 blockchains, each of which can be split up to 2 to the power of 60 shard-chains. Thus, it can support millions of transactions per second almost instantaneously.

*Summary
Hack-a-TONx DoraHacks and crypto projects on TON

Hackathon: everything there is to know
More news on the TON crypto: Telegram’s marketplace
Hack-a-TONx DoraHacks and crypto projects on TON
Titled Hack-a-TONx DoraHacks, the virtual hackathon will offer a total prize pool of {{text}}80,000 in Toncoin (TON). Participants compete to build a myriad of projects on TON, a revolutionary technology to unite all blockchain and Web2 Internet into one open network. So, the goal is to empower billions of Telegram users with a true Web3.*

Justin Hyun, Head of Incubation at the TON Foundation, said on the subject:

“This is a major global hackathon, enabling top talent from around the world to build on TON. We are confident that this event will engage thousands of Web2 and Web3 developers from the TON ecosystem and beyond, showcasing the many possibilities to build on TON. It’s time to join the movement.”

Specifically, the hackathon will kick off on 30 January 2023 with tracks that will include Decentralized finance (DeFi), Social/Decentralized Identifier (DID), Non-Fungible Token (NFT)/Soulbound Tokens (SBT), Decentralized Autonomous Organization (DAO), games, Web3 services (Metaverse) and Web 2.5 (The Ultimate Challenge).

Hackathon: everything there is to know
The hackathon, which will be live-streamed on YouTube, Binance Live and Bilibili, will showcase the depth of global talent building in the TON ecosystem. The event will conclude on 31 March 2023 with a closing ceremony and announcement of the winners, where prize money and gifts will be distributed.

Hyun, in particular, confirmed:

“Funding from the TONcoin Fund will also be up for grabs to the teams that emerge victorious, providing a generous opportunity from a $250 million ecosystem fund dedicated to supporting founders building on The Open Network.”

The hackathon will also benefit applications for The Open Challenge (TOC), a metrics-based TON awards program. In addition, teams that make it to the competition finals may have the opportunity to travel to Dubai for a trip and meet with the TON Foundation‘s management team and investors.

More news on the TON crypto: Telegram’s marketplace
Telegram, the popular messaging app, has developed a new marketplace that does not involve the use of non-fungible tokens (NFTs). In October, the platform said it was ready to launch its marketplace for selling unique usernames for various socials, an idea that was first proposed in August.

In an official announcement on its Telegram channel, the company said that the development phase of the marketplace is nearing an end and that it will be based on The Open Network (TON).

The idea was first put forward in August this year by Pavel Durov, the company’s founder, when he proposed a marketplace capable of using NFT-like smart contracts to auction off highly sought-after usernames.

Durov made the proposal after the success of The Open Network’s (TON) domain name auctions, as anticipated the layer-1 blockchain originally designed by Telegram’s team.

At the time, Durov said that a new marketplace, in which username holders can transfer over interested parties through protected agreements, could become a required service in Web3.

He added that other elements of the Telegram ecosystem, including channels, stickers or emojis, could also later become part of this marketplace. However, like many other platforms from the era of Initial Coin Offerings (ICOs), Telegram also had problems with US regulators due to the unregistered sale of its Gram token.

Thus, after losing a court battle in 2020 against the US Securities and Exchange Commission, Durov walked away from the project to focus on Telegram. Since then, open-source developers have relaunched the project under the banner of The Open Network (TON).

**Exclusively authorized by DoraHacks, please indicate from [yakihonne.com](yakihonne.com)**

Crypto TON Announces Global hackathon in Partnership with DoraHacks


[This article is part of YakiHonne Explore2Earn. Click to earn more Sats"! ](https://www.yakihonne.com/article/naddr1qq2457f4wvk4vhm4vdskv3jpdf5xkaz3feh8sq3qyzvxlwp7wawed5vgefwfmugvumtp8c8t0etk3g8sky4n0ndvyxesxpqqqp65wqfg09z)

![image](https://dorahacks.io/blog/content/images/size/w2000/2022/09/hero-1-1.png)

**Hi bounty hunters!**
DoraHacks and its friends post bounties from time to time. We’re waiting for enthusiastic bounty hunters to tackle them, give best solutions, get rewards, and make the world better. Here’s a guide for you to explore among DoraHacks bounties.

**Start hunting for Bounties!**
*Please log in before claiming any bounty.*

**Step 1: Browse to find bounties for you**
Go to https://dorahacks.io/daobounty or select DAO bounties under Bounties in the Navigation Bar.
![image](https://dorahacks.io/blog/content/images/size/w1000/2022/09/image-5.png)

**Step 2: Participate to show your interest**

Enter any bounty, click on the Participate button to participate in a bounty that you are interested in.
![image](https://dorahacks.io/blog/content/images/size/w1000/2022/09/image-6.png)

You need to connect the wallet to register, and the wallet will be the receiver of the bounty prize money in crypto(ofc, when your solution is accepted by the bounty owner).

When wallet is connected, you will see the page below. Click “Back to Bounty” to proceed.
![image](https://dorahacks.io/blog/content/images/size/w1000/2022/09/image-7.png)

**Step 3: Submit your solution**

![image](https://dorahacks.io/blog/content/images/size/w1000/2022/09/image-8.png)
At “Submit Solution”, you’ll be asked to offer:
1. a link to your deliverable, e.g a Github repo, a Google doc script, a design asset folder…

2. further explanation and other details you want the bounty owner to know.
![image](https://dorahacks.io/blog/content/images/2022/09/5.png)

When solution submitted, you will see the updates of your(and other’s) submission history in the **Activities Section** (at the right part of the page).
![image](https://dorahacks.io/blog/content/images/size/w1000/2022/09/image-9.png)

**How to receive the crypto reward**
When your solution is accepted, you’ll be marked as “Winner” in the Activities. Congrats! You’ll receive the crypto rewards instantly via the registered wallet address. Don’t forget to check out the wallet balance!

![image](![image](https://dorahacks.io/blog/content/images/size/w1000/2022/09/image-10.png)

**FAQ**
**1. What network and token reward are supported?**

At the present moment, we support Polygon and BNB Chain networks. The tokens that could be used for rewards are: MATIC, BNB, USDT, USDC, DAI. We're always evaluating adding more networks where applicable.

**2. What are the fees I will incur?**
We do not charge any fees for publishing and hunting bounties. The amount of reward you set up will be the amount of reward that the hunter can receive. Please be mindful that when publishing bounties there'll be gas fee charged by the blockchain.

**3. Why does it takes very long for the bounty to be published?**

Most of the times, it's due to the network being busy; you can use the Speed Up function in your wallet if your wallet supports the function. However, please be mindful that it may cost a higher gas fee.

**4. What if there's no hunters hunting my bounty?**

When your bounty expired without any hunters participating, you will be able to withdraw the funds.

**5. I was the winner of the bounty but didn't receive the reward?**

This process should be done automatically, once the Bounty publisher releases the funds, after certain time for network confirmations (usually few minutes), you should receive the reward in the wallet you connected with when participating the Bounty.

If you cannot see it in Metamask or the block explorer transaction history, please also check out at block explorer Internal TXNs.

If you didn't see the reward after a while, please reach out to DoraHacks support via Discord: https://discord.gg/gKT5DsWwQ5

**About DoraHacks**
DoraHacks is a global hackathon organizer and one of the world’s most active developer communities. It is an open-source developer platform and open-source curation market. It provides unique on-chain tools to incentivize open-source developments around the world. The platform offers a variety of features including hacker profile, BUIDL, quadratic funding grants, bonding curve, bounties, and hackathons to more than 100,000 users around the world.

**Exclusively authorized by DoraHacks, please indicate from [yakihonne.com](yakihonne.com)**

DoraHacks Bounty Hunters Guide: How to earn crypto as a bounty hunter?


![image](https://filecoin.io/uploads/fil-blog-2021-07-01-dorahacks-1.png?width=2000)

[This article is part of YakiHonne Explore2Earn. Click to earn more Sats"! ](https://www.yakihonne.com/article/naddr1qq2457f4wvk4vhm4vdskv3jpdf5xkaz3feh8sq3qyzvxlwp7wawed5vgefwfmugvumtp8c8t0etk3g8sky4n0ndvyxesxpqqqp65wqfg09z)

Jul 1, 2021
Filecoin Quadratic Funding Grant Round-1 at DoraHacks
Protocol Labs is sponsoring a HackerLink Grant via DoraHacks to fund open source developer projects via donation, so that these projects can develop further into a startup in the Filecoin ecosystem.

DoraHacks is a decentralized global hacker community and hackathon organizer focusing on blockchain with the mission of connecting hackers around the world and helping them solve critical issues in different industries. DoraHacks has organized 100+ featured hackathons, witnessed the launch of 3000+ projects and connected 300000+ hackers from 40+ countries worldwide.

About the Filecoin Quadratic Funding Grant Round-1

Filecoin Quadratic Funding Grant Round-1 runs now until July 18, 2021. Developers participating in this round should submit projects in the ‘Submit BUIDL’ page and select “Filecoin Grant Round 1” as project source. Submitted projects will display on the round’s detail page, and a real-time community donation ranking will be available on the leaderboard. accepts following types of projects, projects should include the following elements:

IPFS & Filecoin for NFTs - Solve a problem that the NFT explosion brings - archiving or organizing collections, NFT backpacks or widgets or other ways to show off your collection, tools for valuation or provenance connections, tools for management and publishing.

Developer Tools - We live in a mostly HTTP world, and all our tools assume it’s the protocol we’ re using. We need you to build new tools for debugging, diagnosing, visualizing or otherwise aiding development with IPFS, Filecoin and libp2p. Anything that makes developers’ lives easier counts!

Decentralizing Data - We challenge you to find existing data and make it available on IPFS - map data, historical data, content archives, financial data. Included in this challenge is tooling - libraries for automatically publishing from existing HTTP datasources to IPFS, or managing updates to existing data, or tools for indexing, searching and managing large data sets.

While the event kicked off in May, the deadline for submissions is still open! Get all of the details on how you can participate.

DoraHacks kicked off with a series of workshops, if you missed them, catch up using the links below:

Introduction to Filecoin workshop with Jim Pick and Jimmy Lee

https://www.youtube.com/watch?v=3hbtHcn0Piw

Preview project demos using IPFS and Filecoin

https://www.youtube.com/watch?v=2d-xftqmrpo

Primer Workshops

Primer Workshop Set 1

https://www.youtube.com/watch?v=1os_C0oOnHU

Part 1: More than just Storage, business opportunities on Filecoin with ZX Zhang

https://www.youtube.com/watch?v=oqRvRiOmPm4

Part 2: An introduction to Filecoin clients and APIs to store your data with Aaron Sutula

Primer Workshop Set 2

https://www.youtube.com/watch?v=0vGmXRj3EA0

Part 1: Minting NFTs from your browser with nft.storage with Yusef Napora

https://www.youtube.com/watch?v=u_LHmhQhgyI

Part 2: The Fleek Toolbox: Guide to Web3 Development on IPFS with Samuele Agostinelli

Apply to the Filecoin Grant and submit your project by July 18, 2021!

**Exclusively authorized by DoraHacks, please indicate from [yakihonne.com](yakihonne.com)**


RockX Partners With DoraHacks to Support Web3 Developers


[This article is part of YakiHonne Explore2Earn. Click to earn more Sats"! ](https://www.yakihonne.com/article/naddr1qq2457f4wvk4vhm4vdskv3jpdf5xkaz3feh8sq3qyzvxlwp7wawed5vgefwfmugvumtp8c8t0etk3g8sky4n0ndvyxesxpqqqp65wqfg09z)

NEWS PROVIDED BY

DoraHacks

03 Mar, 2018, 03:18 ET

BEIJING, March 3, 2018 /PRNewswire/ -- DoraHacks is the largest hackathon organizer and hacker community in China, expanding to 10 countries in 2018. Over three years, DoraHacks has organized more than 100 hackathons globally, operating in 7 cities, 5000+ core hackers and 200k+ developers in community. DoraHacks has produced more than 1000 applications in its hackathons and incubated more than 20 successful startups (including blockchains) in China.

![image](https://mma.prnewswire.com/media/649076/DoraHackers_activities.jpg?w=500)

Dora Hackers from all over the globe enjoyed DoraHacks hackathons' fun and exciting hacking experience.

In February, DoraHacks (www.dorahacks.com) launched its global hackathon programme, planning to host hackathons in more than 10 countries, including South Korea, Japan, UK, India and Switzerland,etc. DoraHacks has organized more than a hundred successful hackathons around China, each of which attracted between 100 and 200 participants. In January 2018, DoraHacks successfully hosted its first US hackathon in San Francisco.

What's DoraHacks? DoraHacks is an international hacker community founded in 2014, with support from Open Wisdom Lab at Tsinghua University. As the biggest hacker organization in China, DoraHacks' mission is to connect the most talented hackers around the world to solve the greatest problems we face in different industries and to overcome practical issues from our diversiform society.

DoraHacks has formed a unique and irreplaceable "Hacker Brain" for the society. Thanks for DoraHacks' standardized and professional event organization teams stationed in 10 countries among the world, hundreds of hackathons have been successfully hosted over the past two years. DoraHacks' Hackathons bring together the world's top universities' outstanding researchers and technology firms' practitioners to create a Technology Utopia, where cooperation and teamwork between hackers are more efficient and innovative ideas may be generated. Hackers have successfully solved 1000+ problems in DoraHacks' 100+ hackathons. With such high frequency of activities, DoraHacks has now successfully become the most professional and the front-running hacker organization in China.

In DoraHacks' Hackathons, hackers will need to solve practical or industry-specific problems within 24 hours using their solid expertise, knowledge and creativity. About half of the problems will be real problems that the sponsors are facing, while the rest will be problems that are raised by hackers and worth solving. Hackers will be divided in teams of 3 to 6, in which members are experts in different aspects, varying from AI technology, UI design to front-end development, etc. Interaction with fellow hackers is a key reason why hackers love DoraHacks. As preeminent hackers are gathered together by DoraHacks, most of them got out of a hackathon feeling they have learned new skills and made some great new friends.

The problem-oriented hackathons DoraHacks hosts have generated many ready-to-use solutions for DoraHacks' sponsors and partners. Therefore it has attracted a number of front-running AI, Fintech and blockchain companies as its sponsors. DoraHacks also initiated a DoraHacker Support Program where more technology firms are welcomed to join the program, providing job opportunities and mentoring directly to DoraHacks' hackers. DoraHacks is also frequently featured on major Chinese media platforms such as Sohu and iFeng.

DoraHacks (www.dorahacks.com), with a mission to connect the most talented hackers around the world, will continue to host outstanding hackathons for hackers, so that every hacker can grow better through interaction and collaboration, and be able to creatively solve real-world problems our industries and society face today.

Exclusively authorized by DoraHacks, please indicate from [yakihonne.com](yakihonne.com)

DoraHacks Successfully Launched "2018 Global Hackathon Programme"


DoraHacks Partnership Proposal with Near


![image](https://www.asiacryptotoday.com/wp-content/uploads/2019/07/cropped-WeChat-Image_20190723093336.jpg)

[This article is part of YakiHonne Explore2Earn. Click to earn more Sats"! ](https://www.yakihonne.com/article/naddr1qq2457f4wvk4vhm4vdskv3jpdf5xkaz3feh8sq3qyzvxlwp7wawed5vgefwfmugvumtp8c8t0etk3g8sky4n0ndvyxesxpqqqp65wqfg09z)

NEO founder and core developer Erik Zhang attended DoraHacks, a leading Chinese hackathon, as a judge from July 19-22.

Based on the event’s theme of “Bringing About the 4th Industrial Transformation,” Erik delivered an opening speech, which focused on how blockchain technology will enable the future of the Internet.

“I am confident that blockchain technology will shape the future of the internet, starting with a paradigm shift in terms of computing. With this, I foresee the Internet shifting from being application-centric to user-centric by giving full control to the users,” he said.

[This article is part of YakiHonne Explore2Earn. Click to earn more Sats"! ](https://www.yakihonne.com/article/naddr1qq2457f4wvk4vhm4vdskv3jpdf5xkaz3feh8sq3qyzvxlwp7wawed5vgefwfmugvumtp8c8t0etk3g8sky4n0ndvyxesxpqqqp65wqfg09z)

“Developers have long been at the core of our company. Through NEO3, we aim to provide enhanced support, an upgraded infrastructure, and a suite of tools to empower our developers to realize next-generation decentralized apps.

“Within the past few decades, China has undergone an Internet transformation, one that’s fundamentally changed people’s lives. Moving forward, NEO anticipates an even greater transformation coming our way as blockchain adoption accelerates, and as we advance towards rolling out NEO3.”

He encouraged participants to embrace innovation and blockchain to accelerate the development of decentralized applications, built on the blockchain, and build a smart economy.

Connecting the future of the Internet and NEO, Erik also discussed the following elements of NEO3’s development and how they are helping better support developers:

• dBFT 2.0 was launched in May – The consensus delegated Byzantine fault tolerance mechanism has been improved to guarantee immediate transaction finality and includes a recovery method to help failed nodes on the NEO network get back online with minimal disruption.

• NeoFS, NeoID, and other products will soon be launched – NeoFS is a distributed decentralized object storage platform integrated with the NEO blockchain, while NeoID is a decentralized identity protocol built by NEO.

At the event Erik also introduced the audience to NEO EcoBoost, describing it as a way for NEO to provide comprehensive support for developers as well as Dapps and infrastructural upgrading.

To find out more about NEO, visit: www.neo.org

Exclusively authorized by DoraHacks, please indicate from [yakihonne.com](yakihonne.com) when reprinting

[This article is part of YakiHonne Explore2Earn. Click to earn more Sats"! ](https://www.yakihonne.com/article/naddr1qq2457f4wvk4vhm4vdskv3jpdf5xkaz3feh8sq3qyzvxlwp7wawed5vgefwfmugvumtp8c8t0etk3g8sky4n0ndvyxesxpqqqp65wqfg09z)

Erik Zhang Offers Insight into NEO's Next Generation Internet at DoraHacks Event


EMURGO Ventures Invests in DoraHacks to Scale Cardano’s Web3 Developer Pool and dApp Ecosystem


![image](https://image.nostr.build/aab8b68f311b0a29ceed061a37f1ae43521150c53db6591791c87c9d468477f6.jpg)

DoraHacks is a global hackathon organization that has gained prominence in innovation and technology. Founded on the principle of fostering creative problem-solving, DoraHacks hosts hackathons and other collaborative events that bring together talented developers, designers, entrepreneurs, and innovators from around the world. These events serve as platforms for individuals to brainstorm, code, and prototype innovative solutions to real-world challenges. DoraHacks has established a reputation for its commitment to promoting open-source development, blockchain technology, and social impact initiatives, making it a hub for forward-thinking individuals passionate about driving positive change through technology. With a strong emphasis on community, collaboration, and cutting-edge technologies, DoraHacks continues to inspire and empower the next generation of problem solvers.

****Key Features of DoraHacks****
![image](https://image.nostr.build/ee539fd4ae34af0532d1349800ac05869d41896c74c3d6ac0df12b4f5576dce2.jpg)

These are some of the key features of Dora

- Global Reach: DoraHacks hosts events on a global scale, bringing together participants and experts from diverse backgrounds and regions.

- Hackathons:  DoraHacks is primarily known for organizing hackathons, where participants collaborate intensively on projects, prototypes, and solutions over a specified time frame.

- Innovation:  The organization emphasizes creative problem-solving and innovation, making it a hub for individuals interested in cutting-edge technologies and solutions.

- Blockchain and Cryptocurrency: DoraHacks has a particular interest in blockchain technology, cryptocurrency, and decentralized applications, often featuring challenges related to these areas.

- Collaboration:  Participants have the opportunity to collaborate with like-minded individuals, forming teams to work on projects and challenges.

- Networking: DoraHacks events provide a platform for networking with experts, mentors, and potential collaborators from the technology and innovation sectors.

- Mentorship: Experienced mentors and industry professionals often participate, providing guidance and support to teams and individuals throughout the hackathon.

- Prizes and Recognition: DoraHacks typically offer prizes, awards, and recognition to winning teams and outstanding participants, which can include cash prizes, partnerships, and opportunities for project development.

- Social Impact: Some DoraHacks events may focus on social impact and encourage participants to develop solutions that address real-world problems.

- Continuous Learning: DoraHacks fosters a culture of continuous learning and skill development, offering workshops, seminars, and opportunities to expand participants' knowledge and expertise.

- Community Building: DoraHacks promotes a sense of community among participants, fostering a collaborative and supportive environment for tech enthusiasts.

**Some Key Areas of DoraHacks**

- **BUILDs**
![image](https://image.nostr.build/a9f392962d4f9a0e83e4341f530b28063c68437717a4c406722ea29ad67297d5.jpg)

This is where you Create a project on DoraHacks to share your ideas with more hackers and investors.

![image](https://image.nostr.build/3ea2c0ccd9e3cf08c4122daa83839e4987341c35e80eea396e3033e244752dfa.jpg)

There are different kinds of Builds; the all Builds (which consists of all things build), the Build collection
![image](https://image.nostr.build/4fa2fd6b23bddd972820dc648542bae726124fd0595a01867084dfac96599137.jpg)

and the Build report which is a report of the build ![image](https://image.nostr.build/ae5b8595dc7f59dda912f62d5803605fae97c9b130b426a7a42f660dce14c9a1.jpg).

- **Grants**
 The Grant programs are established to provide financial support for various purposes, such as research, projects, or community development. There are three forms of grants; **community funding, mini-grants and grant DAOs**

![image](https://image.nostr.build/d0fa531857b2bb5df4c4653b8cccb3dd9f1e06202c8125c72b39351388e66b68.jpg)

![image](https://image.nostr.build/8e86c3ed0e58df9fa62b1dc62de2ff853b094aa5ae9fd87702a6b3e46bcdedf9.jpg)

![image](https://image.nostr.build/1fa7f624f3f32ad49d98c297170210c7a11efff1458144f0d7c2b6f505d36076.jpg)

Depending on the type of grant one is after, one can choose from any of the above grants.

- **Bounties**
 Bounties are essentially challenges or tasks sponsored by companies or organizations that participants can take on to win prizes, often in the form of cash, tokens, or other rewards. These bounties are typically aimed at solving specific problems or achieving particular goals.

- **Hackathons**
There are a series of hackathons organized by DoraHacks at specific periods
![image](https://image.nostr.build/50271156c31cfd1b9aca49c6a7ec3013f69bdf2b50aab23dc717d3750d8aad30.jpg)

- **ideas**
This is where you create and share your ideas with the DoraHacks community
![image](https://image.nostr.build/f9067dd0fcddcdffeb31f18c54b041a9fdd4fc5da7c1b0b19882774a0d0784c9.jpg)

- **Live**
This is for when DoraHacks is hosting a live session for one of their many events, and they can use one or multiple of their several streaming sites. This could be either Binance live, YouTube Live or Bilibili.
![image](https://image.nostr.build/3cafc22ae22df298dd02947d89fec585844162731df2d3d8cc169c0790dca85a.jpg)

This is a really brief navigation of the DoraHacks platform, hope you enjoy your usage of it


 Credit card applications
Commercial banks receive a lot of applications for credit cards. Many of them get rejected for many reasons, like high loan balances, low income levels, or too many inquiries on an individual's credit report, for example. Manually analyzing these applications is mundane, error-prone, and time-consuming (and time is money!). Luckily, this task can be automated with the power of machine learning and pretty much every commercial bank does so nowadays. In this notebook, we will build an automatic credit card approval predictor using machine learning techniques, just like real banks do.

Credit card being held in hand

We'll use the Credit Card Approval dataset from the UCI Machine Learning Repository. The structure of this notebook is as follows:

First, we will start off by loading and viewing the dataset.
We will see that the dataset has a mixture of both numerical and non-numerical features, that it contains values from different ranges, plus that it contains a number of missing entries.
We will have to preprocess the dataset to ensure the machine learning model we choose can make good predictions.
After our data is in good shape, we will do some exploratory data analysis to build our intuitions.
Finally, we will build a machine learning model that can predict if an individual's application for a credit card will be accepted.
First, loading and viewing the dataset. We find that since this data is confidential, the contributor of the dataset has anonymized the feature names.

```

# Import pandas
import pandas as pd

# Load dataset
cc_apps = pd.read_csv("datasets/cc_approvals.data", header=None)

# Inspect data
cc_apps.head()
0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
0	b	30.83	0.000	u	g	w	v	1.25	t	t	1	f	g	00202	0	+
1	a	58.67	4.460	u	g	q	h	3.04	t	t	6	f	g	00043	560	+
2	a	24.50	0.500	u	g	q	h	1.50	t	f	0	f	g	00280	824	+
3	b	27.83	1.540	u	g	w	v	3.75	t	t	5	t	g	00100	3	+
4	b	20.17	5.625	u	g	w	v	1.71	t	f	0	f	s	00120	0	+
```

2. Inspecting the applications
The output may appear a bit confusing at its first sight, but let's try to figure out the most important features of a credit card application. The features of this dataset have been anonymized to protect the privacy, but this blog gives us a pretty good overview of the probable features. The probable features in a typical credit card application are Gender, Age, Debt, Married, BankCustomer, EducationLevel, Ethnicity, YearsEmployed, PriorDefault, Employed, CreditScore, DriversLicense, Citizen, ZipCode, Income and finally the ApprovalStatus. This gives us a pretty good starting point, and we can map these features with respect to the columns in the output.

As we can see from our first glance at the data, the dataset has a mixture of numerical and non-numerical features. This can be fixed with some preprocessing, but before we do that, let's learn about the dataset a bit more to see if there are other dataset issues that need to be fixed.

```
# Print summary statistics
cc_apps_description = cc_apps.describe()
print(cc_apps_description)

print('\n')

# Print DataFrame information
cc_apps_info = cc_apps.info()
print(cc_apps_info)

print('\n')

# Inspect missing values in the dataset
cc_apps.tail(17)
               2           7          10             14
count  690.000000  690.000000  690.00000     690.000000
mean     4.758725    2.223406    2.40000    1017.385507
std      4.978163    3.346513    4.86294    5210.102598
min      0.000000    0.000000    0.00000       0.000000
25%      1.000000    0.165000    0.00000       0.000000
50%      2.750000    1.000000    0.00000       5.000000
75%      7.207500    2.625000    3.00000     395.500000
max     28.000000   28.500000   67.00000  100000.000000

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 690 entries, 0 to 689
Data columns (total 16 columns):
0     690 non-null object
1     690 non-null object
2     690 non-null float64
3     690 non-null object
4     690 non-null object
5     690 non-null object
6     690 non-null object
7     690 non-null float64
8     690 non-null object
9     690 non-null object
10    690 non-null int64
11    690 non-null object
12    690 non-null object
13    690 non-null object
14    690 non-null int64
15    690 non-null object
dtypes: float64(2), int64(2), object(12)
memory usage: 86.3+ KB
None

0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
673	?	29.50	2.000	y	p	e	h	2.000	f	f	0	f	g	00256	17	-
674	a	37.33	2.500	u	g	i	h	0.210	f	f	0	f	g	00260	246	-
675	a	41.58	1.040	u	g	aa	v	0.665	f	f	0	f	g	00240	237	-
676	a	30.58	10.665	u	g	q	h	0.085	f	t	12	t	g	00129	3	-
677	b	19.42	7.250	u	g	m	v	0.040	f	t	1	f	g	00100	1	-
678	a	17.92	10.210	u	g	ff	ff	0.000	f	f	0	f	g	00000	50	-
679	a	20.08	1.250	u	g	c	v	0.000	f	f	0	f	g	00000	0	-
680	b	19.50	0.290	u	g	k	v	0.290	f	f	0	f	g	00280	364	-
681	b	27.83	1.000	y	p	d	h	3.000	f	f	0	f	g	00176	537	-
682	b	17.08	3.290	u	g	i	v	0.335	f	f	0	t	g	00140	2	-
683	b	36.42	0.750	y	p	d	v	0.585	f	f	0	f	g	00240	3	-
684	b	40.58	3.290	u	g	m	v	3.500	f	f	0	t	s	00400	0	-
685	b	21.08	10.085	y	p	e	h	1.250	f	f	0	f	g	00260	0	-
686	a	22.67	0.750	u	g	c	v	2.000	f	t	2	t	g	00200	394	-
687	a	25.25	13.500	y	p	ff	ff	2.000	f	t	1	t	g	00200	1	-
688	b	17.92	0.205	u	g	aa	v	0.040	f	f	0	f	g	00280	750	-
689	b	35.00	3.375	u	g	c	h	8.290	f	f	0	t	g	00000	0	-
```

3. Splitting the dataset into train and test sets
Now, we will split our data into train set and test set to prepare our data for two different phases of machine learning modeling: training and testing. Ideally, no information from the test data should be used to preprocess the training data or should be used to direct the training process of a machine learning model. Hence, we first split the data and then preprocess it.

Also, features like DriversLicense and ZipCode are not as important as the other features in the dataset for predicting credit card approvals. To get a better sense, we can measure their statistical correlation to the labels of the dataset. But this is out of scope for this project. We should drop them to design our machine learning model with the best set of features. In Data Science literature, this is often referred to as feature selection.

```
# Import train_test_split
from sklearn.model_selection import train_test_split

# Drop the features 11 and 13
cc_apps = cc_apps.drop([11, 13], axis=1)

# Split into train and test sets
cc_apps_train, cc_apps_test = train_test_split(cc_apps, test_size=0.33, random_state=42)
```

4. Handling the missing values (part i)
Now we've split our data, we can handle some of the issues we identified when inspecting the DataFrame, including:

Our dataset contains both numeric and non-numeric data (specifically data that are of float64, int64 and object types). Specifically, the features 2, 7, 10 and 14 contain numeric values (of types float64, float64, int64 and int64 respectively) and all the other features contain non-numeric values.
The dataset also contains values from several ranges. Some features have a value range of 0 - 28, some have a range of 2 - 67, and some have a range of 1017 - 100000. Apart from these, we can get useful statistical information (like mean, max, and min) about the features that have numerical values.
Finally, the dataset has missing values, which we'll take care of in this task. The missing values in the dataset are labeled with '?', which can be seen in the last cell's output of the second task.
Now, let's temporarily replace these missing value question marks with NaN.

```
# Import numpy
import numpy as np

# Replace the '?'s with NaN in the train and test sets
cc_apps_train = cc_apps_train.replace('?', np.NaN)
cc_apps_test = cc_apps_test.replace('?', np.NaN)
```

5. Handling the missing values (part ii)
We replaced all the question marks with NaNs. This is going to help us in the next missing value treatment that we are going to perform.

An important question that gets raised here is why are we giving so much importance to missing values? Can't they be just ignored? Ignoring missing values can affect the performance of a machine learning model heavily. While ignoring the missing values our machine learning model may miss out on information about the dataset that may be useful for its training. Then, there are many models which cannot handle missing values implicitly such as Linear Discriminant Analysis (LDA).

So, to avoid this problem, we are going to impute the missing values with a strategy called mean imputation.

```
# Impute the missing values with mean imputation
cc_apps_train.fillna(cc_apps_train.mean(), inplace=True)
cc_apps_test.fillna(cc_apps_train.mean(), inplace=True)

# Count the number of NaNs in the datasets and print the counts to verify
print(cc_apps_train.isnull().sum())
print(cc_apps_test.isnull().sum())
0     8
1     5
2     0
3     6
4     6
5     7
6     7
7     0
8     0
9     0
10    0
12    0
14    0
15    0
dtype: int64
0     4
1     7
2     0
3     0
4     0
5     2
6     2
7     0
8     0
9     0
10    0
12    0
14    0
15    0
dtype: int64
```

6. Handling the missing values (part iii)
We have successfully taken care of the missing values present in the numeric columns. There are still some missing values to be imputed for columns 0, 1, 3, 4, 5, 6 and 13. All of these columns contain non-numeric data and this is why the mean imputation strategy would not work here. This needs a different treatment.

We are going to impute these missing values with the most frequent values as present in the respective columns. This is good practice when it comes to imputing missing values for categorical data in general.

```
# Iterate over each column of cc_apps_train
for col in cc_apps_train.columns:
    # Check if the column is of object type
    if cc_apps_train[col].dtypes == 'object':
        # Impute with the most frequent value
        cc_apps_train = cc_apps_train.fillna(cc_apps_train[col].value_counts().index[0])
        cc_apps_test = cc_apps_test.fillna(cc_apps_train[col].value_counts().index[0])

# Count the number of NaNs in the dataset and print the counts to verify
print(cc_apps_train.isnull().sum())
print(cc_apps_test.isnull().sum())
0     0
1     0
2     0
3     0
4     0
5     0
6     0
7     0
8     0
9     0
10    0
12    0
14    0
15    0
dtype: int64
0     0
1     0
2     0
3     0
4     0
5     0
6     0
7     0
8     0
9     0
10    0
12    0
14    0
15    0
dtype: int64
```

7. Preprocessing the data (part i)
The missing values are now successfully handled.

There is still some minor but essential data preprocessing needed before we proceed towards building our machine learning model. We are going to divide these remaining preprocessing steps into two main tasks:

Convert the non-numeric data into numeric.
Scale the feature values to a uniform range.
First, we will be converting all the non-numeric values into numeric ones. We do this because not only it results in a faster computation but also many machine learning models (like XGBoost) (and especially the ones developed using scikit-learn) require the data to be in a strictly numeric format. We will do this by using the get_dummies() method from pandas.

```
# Convert the categorical features in the train and test sets independently
cc_apps_train = pd.get_dummies(cc_apps_train)
cc_apps_test = pd.get_dummies(cc_apps_test)

# Reindex the columns of the test set aligning with the train set
cc_apps_test = cc_apps_test.reindex(columns=cc_apps_train.columns, fill_value=0)
```

8. Preprocessing the data (part ii)
Now, we are only left with one final preprocessing step of scaling before we can fit a machine learning model to the data.

Now, let's try to understand what these scaled values mean in the real world. Let's use CreditScore as an example. The credit score of a person is their creditworthiness based on their credit history. The higher this number, the more financially trustworthy a person is considered to be. So, a CreditScore of 1 is the highest since we're rescaling all the values to the range of 0-1.

```
# Import MinMaxScaler
from sklearn.preprocessing import MinMaxScaler

# Segregate features and labels into separate variables
X_train, y_train = cc_apps_train.iloc[:, :-1].values, cc_apps_train.iloc[:, [-1]].values
X_test, y_test = cc_apps_test.iloc[:, :-1].values, cc_apps_test.iloc[:, [-1]].values

# Instantiate MinMaxScaler and use it to rescale X_train and X_test
scaler = MinMaxScaler(feature_range=(0, 1))
rescaledX_train = scaler.fit_transform(X_train)
rescaledX_test = scaler.transform(X_test)
```

9. Fitting a logistic regression model to the train set
Essentially, predicting if a credit card application will be approved or not is a classification task. According to UCI, our dataset contains more instances that correspond to "Denied" status than instances corresponding to "Approved" status. Specifically, out of 690 instances, there are 383 (55.5%) applications that got denied and 307 (44.5%) applications that got approved.

This gives us a benchmark. A good machine learning model should be able to accurately predict the status of the applications with respect to these statistics.

Which model should we pick? A question to ask is: are the features that affect the credit card approval decision process correlated with each other? Although we can measure correlation, that is outside the scope of this notebook, so we'll rely on our intuition that they indeed are correlated for now. Because of this correlation, we'll take advantage of the fact that generalized linear models perform well in these cases. Let's start our machine learning modeling with a Logistic Regression model (a generalized linear model).

```
# Import LogisticRegression
from sklearn.linear_model import LogisticRegression

# Instantiate a LogisticRegression classifier with default parameter values
logreg = LogisticRegression()

# Fit logreg to the train set
logreg.fit(rescaledX_train,y_train)
LogisticRegression(C=1.0, class_weight=None, dual=False, fit_intercept=True,
          intercept_scaling=1, max_iter=100, multi_class='ovr', n_jobs=1,
          penalty='l2', random_state=None, solver='liblinear', tol=0.0001,
          verbose=0, warm_start=False)
```

10. Making predictions and evaluating performance
But how well does our model perform?

We will now evaluate our model on the test set with respect to classification accuracy. But we will also take a look the model's confusion matrix. In the case of predicting credit card applications, it is important to see if our machine learning model is equally capable of predicting approved and denied status, in line with the frequency of these labels in our original dataset. If our model is not performing well in this aspect, then it might end up approving the application that should have been approved. The confusion matrix helps us to view our model's performance from these aspects.

```
# Import confusion_matrix
from sklearn.metrics import confusion_matrix

# Use logreg to predict instances from the test set and store it
y_pred = logreg.predict(rescaledX_test)

# Get the accuracy score of logreg model and print it
print("Accuracy of logistic regression classifier: ", logreg.score(rescaledX_test,y_test))

# Print the confusion matrix of the logreg model
confusion_matrix(y_test,y_pred)
Accuracy of logistic regression classifier:  1.0
array([[103,   0],
       [  0, 125]])
```

11. Grid searching and making the model perform better
Our model was pretty good! In fact it was able to yield an accuracy score of 100%.

For the confusion matrix, the first element of the of the first row of the confusion matrix denotes the true negatives meaning the number of negative instances (denied applications) predicted by the model correctly. And the last element of the second row of the confusion matrix denotes the true positives meaning the number of positive instances (approved applications) predicted by the model correctly.

But if we hadn't got a perfect score what's to be done?. We can perform a grid search of the model parameters to improve the model's ability to predict credit card approvals.

scikit-learn's implementation of logistic regression consists of different hyperparameters but we will grid search over the following two:

```
tol
max_iter
# Import GridSearchCV
from sklearn.model_selection import GridSearchCV

# Define the grid of values for tol and max_iter
tol = [0.01, 0.001 ,0.0001]
max_iter = [100, 150, 200]

# Create a dictionary where tol and max_iter are keys and the lists of their values are the corresponding values
param_grid = dict(tol=tol, max_iter=max_iter)
```

12. Finding the best-performing model
We have defined the grid of hyperparameter values and converted them into a single dictionary format which GridSearchCV() expects as one of its parameters. Now, we will begin the grid search to see which values perform best.

We will instantiate GridSearchCV() with our earlier logreg model with all the data we have. We will also instruct GridSearchCV() to perform a cross-validation of five folds.

We'll end the notebook by storing the best-achieved score and the respective best parameters.

While building this credit card predictor, we tackled some of the most widely-known preprocessing steps such as scaling, label encoding, and missing value imputation. We finished with some machine learning to predict if a person's application for a credit card would get approved or not given some information about that person.

```
# Instantiate GridSearchCV with the required parameters
grid_model = GridSearchCV(estimator=logreg, param_grid=param_grid, cv=5)

# Fit grid_model to the data
grid_model_result = grid_model.fit(rescaledX_train, y_train)

# Summarize results
best_score, best_params = grid_model_result.best_score_, grid_model_result.best_params_
print("Best: %f using %s" % (best_score, best_params))

# Extract the best model and evaluate it on the test set
best_model = grid_model_result.best_estimator_
print("Accuracy of logistic regression classifier: ", best_model.score(rescaledX_test,y_test))
Best: 1.000000 using {'max_iter': 100, 'tol': 0.01}
```

Accuracy of logistic regression classifier:  1.0

In this article, we will build an automatic credit card approval predictor using machine learning techniques, just like the real banks do.


1. The most Nobel of Prizes

The Nobel Prize is perhaps the world's most well known scientific award. Except for the honor, prestige and substantial prize money the recipient also gets a gold medal showing Alfred Nobel (1833 - 1896) who established the prize. Every year it's given to scientists and scholars in the categories chemistry, literature, physics, physiology or medicine, economics, and peace. The first Nobel Prize was handed out in 1901, and at that time the Prize was very Eurocentric and male-focused, but nowadays it's not biased in any way whatsoever. Surely. Right?

Well, we're going to find out! The Nobel Foundation has made a dataset available of all prize winners from the start of the prize, in 1901, to 2016. Let's load it in and take a look.

```
# Loading in required libraries
import pandas as pd
import seaborn as sns
import numpy as np

# Reading in the Nobel Prize data
nobel = pd.read_csv('datasets/nobel.csv')

# Taking a look at the first several winners
nobel.head(n=6)
```

2. So, who gets the Nobel Prize?
Just looking at the first couple of prize winners, or Nobel laureates as they are also called, we already see a celebrity: Wilhelm Conrad Röntgen, the guy who discovered X-rays. And actually, we see that all of the winners in 1901 were guys that came from Europe. But that was back in 1901, looking at all winners in the dataset, from 1901 to 2016, which sex and which country is the most commonly represented?

(For country, we will use the birth_country of the winner, as the organization_country is NaN for all shared Nobel Prizes.)

```
# Display the number of (possibly shared) Nobel Prizes handed
# out between 1901 and 2016
display(len(nobel))

# Display the number of prizes won by male and female recipients.
display(nobel['sex'].value_counts())

# Display the number of prizes won by the top 10 nationalities.
nobel['birth_country'].value_counts().head(10)

```

```
911
Male      836
Female     49
Name: sex, dtype: int64
United States of America    259
United Kingdom               85
Germany                      61
France                       51
Sweden                       29
Japan                        24
Canada                       18
Netherlands                  18
Italy                        17
Russia                       17
Name: birth_country, dtype: int64
```

3. USA dominance
Not so surprising perhaps: the most common Nobel laureate between 1901 and 2016 was a man born in the United States of America. But in 1901 all the winners were European. When did the USA start to dominate the Nobel Prize charts?

```
# Calculating the proportion of USA born winners per decade
nobel['usa_born_winner'] = nobel['birth_country']=='United States of America'
nobel['decade'] = (np.floor(nobel['year']/10)*10).astype(int)
prop_usa_winners = nobel.groupby(['decade'], as_index=False)['usa_born_winner'].mean()

# Display the proportions of USA born winners per decade
display(prop_usa_winners)
decade	usa_born_winner
0	1900	0.017544
1	1910	0.075000
2	1920	0.074074
3	1930	0.250000
4	1940	0.302326
5	1950	0.291667
6	1960	0.265823
7	1970	0.317308
8	1980	0.319588
9	1990	0.403846
10	2000	0.422764
11	2010	0.292683
```

4. USA dominance, visualized
A table is OK, but to see when the USA started to dominate the Nobel charts we need a plot!

```
# Setting the plotting theme
sns.set()
# and setting the size of all plots.
import matplotlib.pyplot as plt
plt.rcParams['figure.figsize'] = [11, 7]

# Plotting USA born winners
ax = sns.lineplot(x='decade', y='usa_born_winner', data=nobel)

# Adding %-formatting to the y-axis
from matplotlib.ticker import PercentFormatter
ax.yaxis.set_major_formatter(PercentFormatter(1.0))
```

5. What is the gender of a typical Nobel Prize winner?
So the USA became the dominating winner of the Nobel Prize first in the 1930s and had kept the leading position ever since. But one group that was in the lead from the start, and never seems to let go, are men. Maybe it shouldn't come as a shock that there is some imbalance between how many male and female prize winners there are, but how significant is this imbalance? And is it better or worse within specific prize categories like physics, medicine, literature, etc.?

```
# Calculating the proportion of female laureates per decade
nobel['female_winner'] = nobel['sex']=='Female'
prop_female_winners = nobel.groupby(['decade', 'category'], as_index=False)['female_winner'].mean()
prop_female_winners
# Plotting USA born winners with % winners on the y-axis
ax = sns.lineplot(x='decade', y='female_winner', hue='category', data=prop_female_winners)

# Adding %-formatting to the y-axis
ax.yaxis.set_major_formatter(PercentFormatter(1.0))
```

6. The first woman to win the Nobel Prize
The plot above is a bit messy as the lines are overplotting. But it does show some interesting trends and patterns. Overall the imbalance is pretty large with physics, economics, and chemistry having the largest imbalance. Medicine has a somewhat positive trend, and since the 1990s the literature prize is also now more balanced. The big outlier is the peace prize during the 2010s, but keep in mind that this just covers the years 2010 to 2016.

Given this imbalance, who was the first woman to receive a Nobel Prize? And in what category?

```
# Picking out the first woman to win a Nobel Prize
nobel[nobel['female_winner']==True].nsmallest(1,'year')
year	category	prize	motivation	prize_share	laureate_id	laureate_type	full_name	birth_date	birth_city	...	sex	organization_name	organization_city	organization_country	death_date	death_city	death_country	usa_born_winner	decade	female_winner
19	1903	Physics	The Nobel Prize in Physics 1903	"in recognition of the extraordinary services ...	1/4	6	Individual	Marie Curie, née Sklodowska	1867-11-07	Warsaw	...	Female	NaN	NaN	NaN	1934-07-04	Sallanches	France	False	1900	True
1 rows × 21 columns

```

7. Repeat laureates
For most scientists/writers/activists a Nobel Prize would be the crowning achievement of a long career. But for some people, one is just not enough, and few have gotten it more than once. Who are these lucky few? (Having won no Nobel Prize myself, I'll assume it's just about luck.)

```
# Selecting the laureates that have received 2 or more prizes.
nobel.groupby('full_name').filter(lambda x: len(x)>1)

13 rows × 21 columns
```

8. How old are you when you get the prize?
The list of repeat winners contains some illustrious names! We again meet Marie Curie, who got the prize in physics for discovering radiation and in chemistry for isolating radium and polonium. John Bardeen got it twice in physics for transistors and superconductivity, Frederick Sanger got it twice in chemistry, and Linus Carl Pauling got it first in chemistry and later in peace for his work in promoting nuclear disarmament. We also learn that organizations also get the prize as both the Red Cross and the UNHCR have gotten it twice.

But how old are you generally when you get the prize?

```
# Converting birth_date from String to datetime
nobel['birth_date'] =  pd.to_datetime(nobel['birth_date'], format='%Y-%m-%d')

# Calculating the age of Nobel Prize winners
nobel['age'] = nobel['year'] - nobel['birth_date'].dt.year

# Plotting the age of Nobel Prize winners
sns.lmplot(x='year', y='age', data=nobel, lowess=True, aspect=2, line_kws={'color':'black'})
<seaborn.axisgrid.FacetGrid at 0x7f2f4a2361d0>
```

9. Age differences between prize categories
The plot above shows us a lot! We see that people use to be around 55 when they received the price, but nowadays the average is closer to 65. But there is a large spread in the laureates' ages, and while most are 50+, some are very young.

We also see that the density of points is much high nowadays than in the early 1900s -- nowadays many more of the prizes are shared, and so there are many more winners. We also see that there was a disruption in awarded prizes around the Second World War (1939 - 1945).

Let's look at age trends within different prize categories.

```
# Same plot as above, but separate plots for each type of Nobel Prize
sns.lmplot(x='year', y='age', data=nobel, row='category')
<seaborn.axisgrid.FacetGrid at 0x7f2f4a1a5fd0>
```

10. Oldest and youngest winners
More plots with lots of exciting stuff going on! We see that both winners of the chemistry, medicine, and physics prize have gotten older over time. The trend is strongest for physics: the average age used to be below 50, and now it's almost 70. Literature and economics are more stable. We also see that economics is a newer category. But peace shows an opposite trend where winners are getting younger!

In the peace category we also a winner around 2010 that seems exceptionally young. This begs the questions, who are the oldest and youngest people ever to have won a Nobel Prize?

```
# The oldest winner of a Nobel Prize as of 2016
display(nobel.nlargest(1, 'age'))

# The youngest winner of a Nobel Prize as of 2016
nobel.nsmallest(1, 'age')
```

11. You get a prize!

Hey! You get a prize for making it to the very end of this notebook! It might not be a Nobel Prize, but I made it myself in paint so it should count for something. But don't despair, Leonid Hurwicz was 90 years old when he got his prize, so it might not be too late for you. Who knows.

Before you leave, what was again the name of the youngest winner ever who in 2014 got the prize for "[her] struggle against the suppression of children and young people and for the right of all children to education"?

```
# The name of the youngest winner of the Nobel Prize as of 2016
youngest_winner = 'Malala Yousafzai'
```

The Nobel Foundation has made a dataset available of all prize winners from the start of the prize, in 1901, to 2016. Let's take a look at it


Dr. Semmelweis and the Discovery of Handwashing

In this article, we're going to reanalyze the data that made Semmelweis discover the importance of handwashing