By developing sophisticated algorithms for the analysis of building models, and mapping these functionalities against prefabrication and modular construction manufacturer capabilities, we can improve design, planning, costing and procurement across the entire prefab value chain

Modulize

modulize

Attacking Toxic Comments Kaggle Competition Using Fast.ai K is a good place to learn and practice your Machine Learning skills. It’s also a great place to find the proper dataset for your learning projects. I need a good classification NLP dataset to practice my recently learned fast.ai lesson, and I came across the . The competition is held two years ago and has long concluded, but it doesn’t hurt to submit my scores and see how well I did. This is one of the things Kaggle is great for since in the real world, it will usually be much harder to know how good or bad your model is, whereas, in Kaggle, you’ll see clearly where your performance is in the Leaderboard. aggle Toxic Comment Classification Challenge The Data Set This competition is held by The team, a research initiative founded by and Google (both a part of Alphabet). Its goal is to find out the best model that can classify multiple toxicity types in comments. The toxicity types are: Conversation AI Jigsaw toxic severe_toxic obscene threat insult indentity_hate Comments are given in a training file and a testing file . And you’ll need to predict a probability of each type of toxicity for each comment in . It is a multi-label NLP classification problem. train.cvs test.csv test.csv Look at the Data Let’s first take a look at the data. We need to import the necessary modules and do some logistics to set up the paths for our files. numpy np pandas pd fastai.text * fastai * import as # linear algebra import as # data processing, CSV file I/O (e.g. pd.read_csv) from import from import Notice here we imported everything from fastai.text and fastai modules. Are we against the software engineering best practice here? Actually, not quite. It’s rather a deliberate move in a more iterative and interactive data science kind of way. With all the library available, I can easily test and try different functions/modules without having to go back and import them every time. It will make the explore/experiment flow much more smoothly. But I digressed, let’s load the data and look at it: path = Path( )
path.ls() !mkdir data
!cp -a {path}/*.* ./data/
!ls data path = Path( )
path.ls() df = pd.read_csv(path/ )
df.head() # Kaggle store dataset in the /kaggle/input/ folder, '/kaggle/input/jigsaw-toxic-comment-classification-challenge/' # the /kaggle/input/ folder is read-only, copy away so I can also write to the folder. # make sure everything is correctly copied over '/kaggle/working/data/' # read in the data and have a peak 'train.csv' (The toxicity types are one-hot encoded) The comments are in column and all toxicity types are ‘one-hot’ encoded, we’ll have to do something about it to make it fit into our model later. comment_text (Have a look at one comment) Transfer Learning: Fine-Tune Our Language Model We’ll use transfer learning for this task, to do that, we’ll use a pre-trained model based on Wikipedia called . It is a model that’s already trained from the Wikipedia dataset(or ‘corpus’ in NLP terms) to predict the next words from a giving unfinished sentence. We’ll leverage the ‘language knowledge’ the model already learned from the Wikipedia dataset and build on top of that. To achieve the best results, we’ll need to ‘fine-tune’ the model to make it learn a bit from our ‘comments’ dataset since what people say in the comments are not necessarily the same with the more formal Wiki. Once the language model is fine-tuned, we can then use it to further do our classification task. wikitext-103 Now let’s load the training data into the fast.ai so we can start training the language model first. databunch bs = data_lm = (TextList.from_df(df, path, cols= )
                .split_by_rand_pct( )
                .label_for_lm()
                .databunch(bs=bs)) 64 # set batch size to 64, works for Kaggle Kernels 'comment_text' 0.1 We use fast.ai’s for this task. It is a very flexible and powerful way to address the challenging task of building a pipeline: loading your data into the model. It isolates the entire process into different parts/steps, each step with multiple methods/functions to adapt to different types of data and the ways data is stored. This concept is a lot like the Linux philosophy, highly modulized and with each module only do one thing but really really well. You are free to explore the wonderful API , for the above code though, it does the following things: Data Block API here 1. Import data from Pandas DataFrame named , tell the model to use as input ( ) df comment_text TextList.from_df(df, path, cols=’comment_text’) Note here I can also include the test.csv into the language model. It’s not considered ‘cheating’ since we are not using the labels, just do language model training. 2. Split the training dataset into train/validation set by random 10/90 percent. ( ) .split_by_rand_pct(0.1) 3. Ignore the given labels( since we are only fine-tuning the language model, not training the classifier yet) and use the language model’s ‘predict next word’ as labels. ( ) .label_for_lm() 4. Build the data into a , with batch size . ( ) databunch bs .databunch(bs=bs) Now let’s look at the we just built: databunch (Notice we lost all the toxicity types) Notice that the doesn’t have all the toxicity type labels since we are only fine-tuning the language model. databunch OK, time for some typical fast.ai learning rate adjustments and training: We put our into a , tell it the language model base we want to use ( ) and assign a default dropout rate of . From the graph, find the biggest downward slope and pick the middle point as our learning rate. (For a more detailed explanation of how this ‘fit_one_cycle’ magic is done, please refer to this . It is a SOTA technique of fast.ai that combines learning rate and momentum annealing). Now we can ‘unfreeze’ the model and train the entire model couple of epochs: databunch language_model_learner AWD_LSTM 0.3 LR Finder article We can look at one example of how well the model did: The result is hardly optimal. But we at least get a sentence that actually makes sense and 0.38 accuracy for predicting the next word is not bad. Ideally, we need to train a bit more epochs but for this Kaggle Kernel, I was running out of GPU quota so I stopped at 4. The result definitely has room to improve and you can try it yourself. Anyway, what we want from the language model is the encoder part, so we save it. Training the language model does take quite some time, but the good news is, for your own domain corpus, you only have to train once and later you can use it as a base for any other classification tasks. learn.save_encoder( ) # save the encoder for next step use 'fine_tuned_enc' Transfer Learning: Training the Classifier Let’s read in the test dataset: test = pd.read_csv(path/ )
test_datalist = TextList.from_df(test, cols= ) "test.csv" 'comment_text' Again, build our : databunch data_cls = (TextList.from_csv(path, , cols= , vocab=data_lm.vocab)
                .split_by_rand_pct(valid_pct= )
                .label_from_df(cols=[ , , , , , ], label_cls=MultiCategoryList, one_hot= )
                .add_test(test_datalist)
                .databunch())
data_cls.save( ) 'train.csv' 'comment_text' 0.1 'toxic' 'severe_toxic' 'obscene' 'threat' 'insult' 'identity_hate' True 'data_clas.pkl' Please note the difference this time: 1. When building the TextList , we specified vocab=data_lm.vocab , this way we make sure we are using the same vocabulary and our training on the language model can be properly applied to the classifier model. 2. We now use all our toxicity styles labels ( ) .label_from_df(cols=[‘toxic’, ‘severe_toxic’,’obscene’, ‘threat’, ‘insult’, ‘identity_hate’],label_cls=MultiCategoryList, one_hot=True), 3. We added our test set here. ( ) .add_test(test_datalist) Now look at our classifier : databunch (Note that now we have all the toxicity styles labels) We’ll put the into the model and load the encoder we learned from the language model. Finally, time to put everything together! databunch text_classifier_learner learn = text_classifier_learner(data_clas, AWD_LSTM, drop_mult= )
learn.load_encoder( ) 0.5 'fine_tuned_enc' Again, find the best learning rate and train one cycle: Train a bit more cycles and unfreeze: See the results: Off by one, but overall the prediction is OK. For the purpose of reference, I submitted the prediction to Kaggle and get a 0.98098 Public Score (land in the middle of the Public Leader Board). The result is not optimal but like I said I didn’t train all the way due to limited GPU. The purpose of this article is to show you the whole process of using fast.ai to tackle multi-labels text classification problem. The real challenge here is to load the data into the model using Data Block API. Conclusion I hope you learned a thing or two from this article. Fast.ai is really a lean, flexible and powerful library. For the things it can do (like image/text classification, tabular data, collaborative filtering, etc.), it does it very well. It is not as extensive as Keras, but it’s very sharp and focused. Kind of like Vim and Emacs if you are familiar with the command line text editor war. 😜 You can find the Kaggle Kernel . here Any feedback or constructive criticism is welcomed. You can either find me on Twitter or my blog site . @lymenlee wayofnumbers.com

How to Build a Multi-label NLP Classifier from Scratch

Hey there, fellow Android developers! 👋 Are you tired of the hassle that comes with managing assisted injection in your modular app? Well, buckle up because I've got some exciting news for you! 🚀 Introducing Anvil Utils - a game-changing library that will make your life easier when working with Dagger and Anvil in multi-module projects. The Struggle Is Real Picture this: you have a beautifully architected modular app with api and implementation modules per feature. Everything is going smoothly until you encounter a situation where your feature contains a factory for an entity and want to expose it in an api, and you need to make this factory available within the Dagger graph. 😰 Let's walk through the ways to do that. Bare Dagger Approach For instance, you have such public API for your feature module: interface MyClass {
	interface Factory {
	    fun create(param1: String, param2: Int): MyClass
	}
} Traditionally, you'd have to manually create an @AssistedFactory in the implementation module, inherit from the public interface in the API module, and write a Dagger module which binds assisted factory to it's public interface. Also, you would need to maintain both factory interfaces - public one and implementation one. Here's an example: class DefaultMyClass @AssistedInject constructor(
    @Assisted param1: String,
    @Assisted param2: Int
) : MyClass {
	@AssistedFactory
	interface Factory: MyClass.Factory {
		override fun create(param1: String, param2: Int): DefaultMyClass
	}
}

@Module
interface MyClassFactoryBindingModule {
	@Binds
	fun bindFactory(impl: DefaultMyClass.Factory): MyClass.Factory
} Seems like a lot of work, doesn't it? Let's make it easier to maintain step by step Introducing Anvil Anvil is a Kotlin compiler plugin which helps to drastically reduce the boilerplate needed to use Dagger 2 in your application. Also, if properly configured, it can improve build times in your application by removing the requirement to run Dagger 2 annotation processor in your feature modules. I will not dive deep into what Anvil is and why you should consider using it. That's a topic for another day. Please read through the Anvil readme here to get what it is about. https://github.com/square/anvil Thanks to Anvil, you can get rid of the binding module using @ContributesBinding: class DefaultMyClass @AssistedInject constructor(
    @Assisted param1: String,
    @Assisted param2: Int
) : MyClass {
	@ContributesBinding(AppGraph::class, MyClass.Factory::class)
	@AssistedFactory
	interface Factory: MyClass.Factory {
		override fun create(param1: String, param2: Int): DefaultMyClass
	}
} Anvil will generate corresponding module which will bind DefaultMyClass.Factory to MyClass.Factory for you. This lowers the amount of boilerplate, but it's still there! You have to manually keep public factory interface and implementation interface aligned with the constructor! Can we go further and reduce the amount of work needed to support this use case? Sure! @ContributesAssistedFactory to the Rescue! Fear not, my friend! With Anvil Utils, you can say goodbye to the manual labor of creating assisted factories. The @ContributesAssistedFactory annotation is here to save the day! 🦸‍♂️ This powerful annotation automatically generates assisted factories for your annotated classes and contributes them to the specified scope as bindings of the provided factory type. It's like having a personal assistant that takes care of all the heavy lifting for you! You now can remove the @AssistedFactory interface completely and annotate the DefaultMyClass with @ContributesAssistedFactory: @ContributesAssistedFactory(AppGraph::class, MyClass.Factory::class)
class DefaultMyClass @AssistedInject constructor(
    @Assisted param1: String,
    @Assisted param2: Int
) : MyClass And voila! Anvil Utils will generate the necessary assisted factory for you, without breaking a sweat. 😎 In the Wild Example To demonstrate the power of this library, I've made a huge pull request to beautiful open-source project - companion app for the Flipper - Tamagochi for hackers. Please, take a look if you're interested: https://github.com/flipperdevices/Flipper-Android-App/pull/79 Embrace the Power of Anvil Utils So, what are you waiting for? Give Anvil Utils a try in your next modular Android project and experience the joy of hassle-free assisted injection. Your codebase will thank you, and your fellow developers will be in awe of your newfound superpowers! 💪 Happy coding, and may the power of Anvil Utils be with you! 🚀 P.S. Don't hesitate to open feature requests - I'm eager to improve the library and add more features. Hey there, fellow Android developers! 👋 Are you tired of the hassle that comes with managing assisted injection in your modular app? Well, buckle up because I've got some exciting news for you! 🚀 Introducing Anvil Utils - a game-changing library that will make your life easier when working with Dagger and Anvil in multi-module projects. Anvil Utils Anvil Utils Anvil The Struggle Is Real Picture this: you have a beautifully architected modular app with api and implementation modules per feature. Everything is going smoothly until you encounter a situation where your feature contains a factory for an entity and want to expose it in an api , and you need to make this factory available within the Dagger graph. 😰 api implementation api Let's walk through the ways to do that. Bare Dagger Approach For instance, you have such public API for your feature module: interface MyClass {
	interface Factory {
	    fun create(param1: String, param2: Int): MyClass
	}
} interface MyClass {
	interface Factory {
	    fun create(param1: String, param2: Int): MyClass
	}
} Traditionally, you'd have to manually create an @AssistedFactory in the implementation module, inherit from the public interface in the API module, and write a Dagger module which binds assisted factory to it's public interface. Also, you would need to maintain both factory interfaces - public one and implementation one. Here's an example: @AssistedFactory class DefaultMyClass @AssistedInject constructor(
    @Assisted param1: String,
    @Assisted param2: Int
) : MyClass {
	@AssistedFactory
	interface Factory: MyClass.Factory {
		override fun create(param1: String, param2: Int): DefaultMyClass
	}
}

@Module
interface MyClassFactoryBindingModule {
	@Binds
	fun bindFactory(impl: DefaultMyClass.Factory): MyClass.Factory
} class DefaultMyClass @AssistedInject constructor(
    @Assisted param1: String,
    @Assisted param2: Int
) : MyClass {
	@AssistedFactory
	interface Factory: MyClass.Factory {
		override fun create(param1: String, param2: Int): DefaultMyClass
	}
}

@Module
interface MyClassFactoryBindingModule {
	@Binds
	fun bindFactory(impl: DefaultMyClass.Factory): MyClass.Factory
} Seems like a lot of work, doesn't it? Let's make it easier to maintain step by step Introducing Anvil Anvil is a Kotlin compiler plugin which helps to drastically reduce the boilerplate needed to use Dagger 2 in your application. Anvil Also, if properly configured, it can improve build times in your application by removing the requirement to run Dagger 2 annotation processor in your feature modules. I will not dive deep into what Anvil is and why you should consider using it. That's a topic for another day. Please read through the Anvil readme here to get what it is about. https://github.com/square/anvil https://github.com/square/anvil Thanks to Anvil, you can get rid of the binding module using @ContributesBinding : @ContributesBinding class DefaultMyClass @AssistedInject constructor(
    @Assisted param1: String,
    @Assisted param2: Int
) : MyClass {
	@ContributesBinding(AppGraph::class, MyClass.Factory::class)
	@AssistedFactory
	interface Factory: MyClass.Factory {
		override fun create(param1: String, param2: Int): DefaultMyClass
	}
} class DefaultMyClass @AssistedInject constructor(
    @Assisted param1: String,
    @Assisted param2: Int
) : MyClass {
	@ContributesBinding(AppGraph::class, MyClass.Factory::class)
	@AssistedFactory
	interface Factory: MyClass.Factory {
		override fun create(param1: String, param2: Int): DefaultMyClass
	}
} Anvil will generate corresponding module which will bind DefaultMyClass.Factory to MyClass.Factory for you. Anvil DefaultMyClass.Factory MyClass.Factory This lowers the amount of boilerplate, but it's still there! You have to manually keep public factory interface and implementation interface aligned with the constructor! Can we go further and reduce the amount of work needed to support this use case? Sure! @ContributesAssistedFactory to the Rescue! Fear not, my friend! With Anvil Utils , you can say goodbye to the manual labor of creating assisted factories. The @ContributesAssistedFactory annotation is here to save the day! 🦸‍♂️ Anvil Utils Anvil Utils @ContributesAssistedFactory This powerful annotation automatically generates assisted factories for your annotated classes and contributes them to the specified scope as bindings of the provided factory type. It's like having a personal assistant that takes care of all the heavy lifting for you! You now can remove the @AssistedFactory interface completely and annotate the DefaultMyClass with @ContributesAssistedFactory : @AssistedFactory DefaultMyClass @ContributesAssistedFactory @ContributesAssistedFactory(AppGraph::class, MyClass.Factory::class)
class DefaultMyClass @AssistedInject constructor(
    @Assisted param1: String,
    @Assisted param2: Int
) : MyClass @ContributesAssistedFactory(AppGraph::class, MyClass.Factory::class)
class DefaultMyClass @AssistedInject constructor(
    @Assisted param1: String,
    @Assisted param2: Int
) : MyClass And voila! Anvil Utils will generate the necessary assisted factory for you, without breaking a sweat. 😎 Anvil Utils Anvil Utils In the Wild Example To demonstrate the power of this library, I've made a huge pull request to beautiful open-source project - companion app for the Flipper - Tamagochi for hackers. Please, take a look if you're interested: https://github.com/flipperdevices/Flipper-Android-App/pull/79 https://github.com/flipperdevices/Flipper-Android-App/pull/79 Embrace the Power of Anvil Utils So, what are you waiting for? Give Anvil Utils a try in your next modular Android project and experience the joy of hassle-free assisted injection. Your codebase will thank you, and your fellow developers will be in awe of your newfound superpowers! 💪 Anvil Utils Anvil Utils Happy coding, and may the power of Anvil Utils be with you! 🚀 Anvil Utils Anvil Utils P.S. Don't hesitate to open feature requests - I'm eager to improve the library and add more features. P.S.

Effortless Assisted Injection in Multi-Module Android Projects: Introducing Anvil Utils

DUBAI, UAE, April 18th, 2024/Chainwire/--SeedHunter, is a dedicated platform that facilitates and fosters collaborations between influencers and crypto projects to gain traction in the web3 community. The company has a new and fresh perspective on how to match high-potential influencers and KOLs with respective crypto projects and investors in a lucrative, scalable, and secure way. SeedHunter launched on April 18th 2024, its debut service: The Marketing Module. This is a platform that allows crypto projects to manage and maintain their influencer marketing campaigns more efficiently, securely, and effectively. The marketing campaigns launched can be uniquely customized to the crypto project’s needs in terms of content, deliverables, and more. The platform then uses an AI-based data model to evaluate, rate, and match reliable KOLs to crypto projects. SeedHunter will also assess influencer performance and define pricing directly using an advanced algorithm based on metrics of engagement, impression rates, number of followers, and the compatibility of the KOL with the campaign they manage - all of these standards will ensure that the right influencer is matched to the user's target audience needs. This ensures a fully transparent, fair, and lucrative influencer marketing position for influencers of all kinds. Crypto projects can also benefit from several built-in marketing campaign tools to drive engagement - including consultancy and account management as needed. SeedHunter takes care of all the tedious admin to provide a simplified, insightful, and efficient platform to view potential influencer and KOL partnerships. Dariusz Kowalczyk, the co-founder and CTO of SeedHunter, has stated that the platform “does the due diligence to find reliable and relevant KOLs that match your target audience’s interests. This saves time and energy while pulling the focus onto the customer.” SeedHunter also makes cryptocurrency projects a lot more accessible by simplifying processes. Influencer campaigns can be created in a matter of minutes through a centralized platform - giving the community automated contracts, KOL reviews, and delivery checks. Payments will also be based on deliveries to ensure cost-effective marketing. The web3 community can easily use SeedHunter to curate the ideal influencer campaign for their project and push growth. To celebrate its official launch, SeedHunter is diving right in with a platform campaign open to all interested KOLs. This provides an opportunity for influencers to get involved from the get-go. SeedHunter has also three additional, high-profile projects waiting to be launched. These span the exciting realms of blockchain, entertainment, and gaming, offering KOLs a chance to contribute to cutting-edge initiatives and propel their marketing efforts. The crypto industry is uniquely disruptive and as such, it needs platforms like SeedHunter that offer scalable solutions from the very beginning for a lasting chance of success. With automated, simplified, and user-friendly interfaces, SeedHunter provides a seamless experience for influencers and crypto projects alike. Co-founder and CEO, Junaid Dar has said, “The SeedHunter platform will act as a canvas for prospective reliable influencers and KOLs to connect to crypto projects that are looking to gain traction in the market in a way that will simplify, secure, and inspire the industry.” SeedHunter is built on the values of trust, efficiency, collaboration, dynamics, and prosperity. This has helped the company establish a clear, guided vision for the future of the crypto influencer market. The platform’s ultimate mission is to ensure an easier, scalable, and more secure channel through which innovative crypto projects can be matched to specific influencers and investors in a way that adds value and clarity to a dynamic cryptocurrency market. SeedHunter invites crypto project managers and influencers of all sizes to take advantage of the Marketing Module that simplifies collaborations in a mutually beneficial, fair, and secure way. SeedHunter is also open to partnerships in the cryptocurrency industry that would help to expand and establish the vision of efficient, secure, and reliable collaborations across the web3 community. Moving forward, SeedHunter will also be launching its Funding Module in June 2024 which will allow crypto projects to find the necessary seed capital needed to gain traction. In this project, SeedHunter will act as a broker between the community and crypto projects that need funding. This project ensures the involvement of smaller influencers as well and allows the project to engage with communities and participate in projects for only $50. This ensures safety, transparency, and safety for start-up crypto projects looking to change the industry. About SeedHunter SeedHunter was founded recently and allows crypto projects to connect to reliable and trusted influencers and KOLs to drive engagement and improve marketability. The centralized platform establishes a mutually beneficial link between influencers and crypto investors that is mutually beneficial and transparent. The company uses advanced technology to match ideal influencer candidates to crypto projects and helps to source seed funding for start-up crypto projects. Contact Information Website: www.seedhunter.com
Email: contact@seedhunter.com
Twitter: @SeedHunterHQ
LinkedIn: SeedHunter Contact Chief Operating Officer Alexandre Barros SeedHunter contact@seedhunter.com This story was distributed as a release by Chainwire under HackerNoon’s Business Blogging Program. Learn more about the program here. DUBAI, UAE, April 18th, 2024/Chainwire/--SeedHunter, is a dedicated platform that facilitates and fosters collaborations between influencers and crypto projects to gain traction in the web3 community. The company has a new and fresh perspective on how to match high-potential influencers and KOLs with respective crypto projects and investors in a lucrative, scalable, and secure way. SeedHunter launched on April 18th 2024, its debut service: The Marketing Module. This is a platform that allows crypto projects to manage and maintain their influencer marketing campaigns more efficiently, securely, and effectively. The marketing campaigns launched can be uniquely customized to the crypto project’s needs in terms of content, deliverables, and more. The platform then uses an AI-based data model to evaluate, rate, and match reliable KOLs to crypto projects. SeedHunter will also assess influencer performance and define pricing directly using an advanced algorithm based on metrics of engagement, impression rates, number of followers, and the compatibility of the KOL with the campaign they manage - all of these standards will ensure that the right influencer is matched to the user's target audience needs. This ensures a fully transparent, fair, and lucrative influencer marketing position for influencers of all kinds. Crypto projects can also benefit from several built-in marketing campaign tools to drive engagement - including consultancy and account management as needed. SeedHunter takes care of all the tedious admin to provide a simplified, insightful, and efficient platform to view potential influencer and KOL partnerships. Dariusz Kowalczyk, the co-founder and CTO of SeedHunter, has stated that the platform “does the due diligence to find reliable and relevant KOLs that match your target audience’s interests. This saves time and energy while pulling the focus onto the customer.” Dariusz Kowalczyk, the co-founder and CTO of SeedHunter, has stated that the platform “does the due diligence to find reliable and relevant KOLs that match your target audience’s interests. This saves time and energy while pulling the focus onto the customer.” SeedHunter also makes cryptocurrency projects a lot more accessible by simplifying processes. Influencer campaigns can be created in a matter of minutes through a centralized platform - giving the community automated contracts, KOL reviews, and delivery checks. Payments will also be based on deliveries to ensure cost-effective marketing. The web3 community can easily use SeedHunter to curate the ideal influencer campaign for their project and push growth. To celebrate its official launch, SeedHunter is diving right in with a platform campaign open to all interested KOLs. This provides an opportunity for influencers to get involved from the get-go. SeedHunter has also three additional, high-profile projects waiting to be launched. These span the exciting realms of blockchain, entertainment, and gaming, offering KOLs a chance to contribute to cutting-edge initiatives and propel their marketing efforts. The crypto industry is uniquely disruptive and as such, it needs platforms like SeedHunter that offer scalable solutions from the very beginning for a lasting chance of success. With automated, simplified, and user-friendly interfaces, SeedHunter provides a seamless experience for influencers and crypto projects alike. Co-founder and CEO, Junaid Dar has said, “The SeedHunter platform will act as a canvas for prospective reliable influencers and KOLs to connect to crypto projects that are looking to gain traction in the market in a way that will simplify, secure, and inspire the industry.” Co-founder and CEO, Junaid Dar has said, “The SeedHunter platform will act as a canvas for prospective reliable influencers and KOLs to connect to crypto projects that are looking to gain traction in the market in a way that will simplify, secure, and inspire the industry.” SeedHunter is built on the values of trust, efficiency, collaboration, dynamics, and prosperity. This has helped the company establish a clear, guided vision for the future of the crypto influencer market. The platform’s ultimate mission is to ensure an easier, scalable, and more secure channel through which innovative crypto projects can be matched to specific influencers and investors in a way that adds value and clarity to a dynamic cryptocurrency market. SeedHunter invites crypto project managers and influencers of all sizes to take advantage of the Marketing Module that simplifies collaborations in a mutually beneficial, fair, and secure way. SeedHunter is also open to partnerships in the cryptocurrency industry that would help to expand and establish the vision of efficient, secure, and reliable collaborations across the web3 community. Moving forward, SeedHunter will also be launching its Funding Module in June 2024 which will allow crypto projects to find the necessary seed capital needed to gain traction. In this project, SeedHunter will act as a broker between the community and crypto projects that need funding. This project ensures the involvement of smaller influencers as well and allows the project to engage with communities and participate in projects for only $50. This ensures safety, transparency, and safety for start-up crypto projects looking to change the industry. About SeedHunter SeedHunter was founded recently and allows crypto projects to connect to reliable and trusted influencers and KOLs to drive engagement and improve marketability. The centralized platform establishes a mutually beneficial link between influencers and crypto investors that is mutually beneficial and transparent. The company uses advanced technology to match ideal influencer candidates to crypto projects and helps to source seed funding for start-up crypto projects. Contact Information Website: www.seedhunter.com Email: contact@seedhunter.com Twitter: @SeedHunterHQ LinkedIn: SeedHunter Website: www.seedhunter.com www.seedhunter.com www.seedhunter.com Email: contact@seedhunter.com contact@seedhunter.com contact@seedhunter.com Twitter: @SeedHunterHQ @SeedHunterHQ @SeedHunterHQ LinkedIn: SeedHunter SeedHunter SeedHunter Contact Chief Operating Officer Alexandre Barros SeedHunter contact@seedhunter.com This story was distributed as a release by Chainwire under HackerNoon’s Business Blogging Program. Learn more about the program here. This story was distributed as a release by Chainwire under HackerNoon’s Business Blogging Program. Learn more about the program here. here. here.

SeedHunter Marketing Module Is live - Web3 Influencer Campaigns With Payment In Stable Coins

How to Integrate React and AngularJS via Webpack Module Federation

Whether it's a React front-end app, a Go CLI tool, or a UI design project, there is always initial toil to figure out the optimal folder structure. As this initial decision influences a lot of flexibility, extensibility, self-explanation, and easy maintenance in our projects, it is key decision to ensure a smooth developer experience. When working with a new tool/technology/framework, our journey typically starts with reading official "getting started" handbook from their official website or even reading some articles on the same topic. We use these resources and start getting our hands dirty with hands-on experience, often using its structure as a foundation for more complex real-world projects. But these articles or tutorials are often serve us good in initial phases of the project, when the complexity is low. When we are solving complex problem involving multiple actors, the legibility and maintainability takes precedence. It becomes a daunting task to later refactor or sometimes rewrite everything from the scratch. To reduce this hassle and tackle this issue head on, I've distilled my Terraform experience into a CLI tool. This tool generates a battle-tested folder structure along with basic modules, allowing us to quickly hit the ground running. Structuring Terraform Folders Most companies and their ops teams find it cumbersome to manage multiple environments across multiple regions for their applications. We can structure our terraform folders as follows: Folder structure organized by Region Folder structure by Resources ( like AWS EC2, or Azure Functions etc) Folder structure on use case ( like front-end app, networking etc) Folder structure organized by Account Folder structure organized by environment and A Hybrid of all the above Given the above options it quite becomes confusing to the teams starting with terraform to decide how to structure their projects. Based on my experience here are my 2 cents on how to structure a terraform project: Create a modular style code with each module containing all the resources required to create for each use-case. These modules would serve as base blueprints which can be utilized across different environments. For ex: In case of AWS, The front-end module should consist of Cloud-front, S3 bucket, cloud-front origin access control, s3 policy bucket policy and s3 bucket public access block. Create a folder structure for each of the environments that you are deploying. This statement would be true, if the architecture across all the environments doesn't change and their deployment strategies does not change. Tfblueprintgen: A Terraform tool to generate folder structure and base blueprints Based on the above postulates, i have created a CLI tool called Tfblueprintgen, which generates the folder structure along with the modular working blocks to create AWS building blocks.  In terms of folder structure, the structure will look something like below. To run the tool download the both windows and Linux binaries from or you can build your own binary from .  Use the the binary ( if in Windows double-click to run Tfblueprintgen.exe or if it is Linux run the binary using ./Tfblueprintgen) here here As described in the image 1, the tool generates two things: A Parent folder which contains all the main terraform files ( , variables and )for each environment separated in their own folders. outputs.tf .tf main.tf A Module folder which contains all the different basic resources, segregated in their own separate folders. These modules can be leveraged within each of the environment folders, by calling those modules using module block and these can be applied using “terraform apply” With this setup, you can hit the ground up and running in no time. Feel free to add more ideas as issues and Stay tuned to project. Liked my content? Feel free to reach out to my for interesting content and productive discussions. LinkedIn

Tfblueprintgen: A Tool to Simplify Terraform Folder Setup and Provide Base Resource Modules

The os package in Python provides a wide range of functionalities for interacting with the operating system. One of the most commonly used aspects of this package is its ability to perform file and folder operations such as iteration, deletion, creation, moving, and opening. In this article, we'll explore how to utilize the os package for these tasks. Iterate Through All the Items Within a Folder You can use the os package in Python to iterate through all the items within a folder using the os.listdir() method. And you can use the os.path.join function to concatenate the folder path with each item in the folder to get the absolute path. Here's an example of how to do it: import os

# Replace 'folder_path' with the path of the folder you want to iterate through
folder_path = 'path_to_folder'

# Iterate through all items in the folder
for item in os.listdir(folder_path):
		print(item) 
		# Get the absolute path of the item
		item_path = os.path.join(folder_path, item) 
		# Display the absolute path of the item
		print(item_path) In this example, returns a list of all the items (files and subfolders) in the specified folder. You can then iterate through this list and perform any operations you need for each item. os.listdir(folder_path) Remember to replace with the actual path of the folder you want to iterate through. 'path_to_folder' Deleting Files and Folders The package provides methods to delete both files and folders. Here's how you can achieve this: os To Delete a File: import os
os.remove('file_path/file.txt') To Delete an Empty Folder: import os
os.rmdir('folder_path')  # Replace with the actual folder path To Delete a Non-Empty Folder and All Its Contents: import shutil
shutil.rmtree('folder_path')  # Replace with the actual folder path Remember to replace and with the actual paths of the file or folder you want to delete. Use these functions with caution as they will permanently delete the specified files or folders. 'file_path/file.txt' 'folder_path' Creating Folders Creating a new folder using the package is straightforward: os import os
os.mkdir('new_folder')  # Replace with the desired folder name Moving and Renaming Files/Folders The package allows us to move and rename files and folders as well. Here's an example of moving a file: os import os
os.rename('old_location/file.txt', 'new_location/file.txt') Opening Files and Folders You can also open a folder in the default file explorer using the package. For instance, to open a folder in the File Explorer (Windows): os import os
os.startfile('folder_path')  # Replace with the actual folder path Conclusion The package in Python offers powerful capabilities for file and folder operations, allowing developers to efficiently manage file system tasks within their applications. os By utilizing the methods provided by the package, you can seamlessly iterate, delete, create, move, and open files and folders in your Python programs. os Thank you for taking the time to explore data-related insights with me. I appreciate your engagement. If you find this information helpful, I invite you to follow me or connect with me on . Happy exploring!👋 LinkedIn Also published here

How to Use the os Module for High-Level File Operations Such as Iterating, Moving, and More

Module Design Pattern is a way to encapsulate and organize code in a self-containing module that can expose certain functionalities while keeping the rest of the code private. This helps prevent variable and function name clashes, improves code maintainability, and promotes the concept of separation of concerns. Here's an example of how you can implement the Module Design Pattern in JavaScript: // Module using the Module Design Pattern
var Module = (function() {
  // Private variable
  var privateVariable = "I am a private variable";

  // Private function
  var privateFunction = function privateFunction() {
    console.log("This is a private function");
  }

  // Public function
  var publicFunction = function() {
      console.log("This is a public function");
  }
  // Public interface
  return {
    publicFunction:publicFunction,
    // Public variable accessing private variable
    publicVariable: privateVariable
  };
})();

// Usage of the module
console.log(Module.publicVariable); // Output: "I am a private variable"
Module.publicFunction(); // Output: "This is a public function"

// Trying to access private members directly (will result in an error)
console.log(Module.privateVariable); // Output: undefined
Module.privateFunction(); // Output: Uncaught TypeError: MyModule.privateFunction is not a function In the above example, we've created a module called using an . Inside the IIFE, we define private variables and functions that are not accessible from outside the module. We then return an object containing the public members (functions and variables) that we want to expose. Module Immediately Invoked Function Expression (IIFE) Benefits of the Module Design Pattern: Private members are not accessible from outside the module, which helps prevent unintended modifications or conflicts with other parts of the codebase. Encapsulation: Code is organized into logical modules, making it easier to manage and understand. Organization: The module acts as a namespace, reducing the chances of naming collisions in a global scope. Namespacing: Modules can be easily reused in different parts of your application or different projects. Reusability: Separation of concerns and encapsulation make it easier to maintain and refactor code. Maintenance: That's a concise explanation of the module design pattern in Javascript. Feel free to comment on how you like my blog or shoot me an email at If you have any queries, and I will try to answer. connect@nandan.dev You can also visit my website to read some of the articles at nandan.dev Stay tuned & connect with me on my social media channels. Make sure to subscribe to my newsletter to get regular updates on my upcoming posts. | | | Twitter Instagram Github Website Also published . here

A Quick Module Design Pattern Example in JavaScript

The joy of coding Python should be in seeing short, concise, readable classes that express a lot of action in a small amount of clear code -- not in reams of trivial code that bores the reader to death. - Guido van Rossum,Creator of python Python powers a wide range of technologies, from smartphone apps to spaceships and robots in industrial plants. The language's and the fact that developers can do whatever they want with it have made it popular. versatility Why Python with DevOps? As an approach to culture, platform, and automation, Python is an important language for DevOps teams working to automate repetitive tasks, infrastructure management, provisioning, Api driven deployment. Since the advent, we now have MLOps, NetDevOps, SecOps, and GitOps… Knowing the basics of Python is precious to developers. Let’s discover the 5 important modules to shine in your DevOps journey: Requests In the past few years, more and more companies have embraced the REST paradigm to interact with smart devices and servers. This module makes HTTP requests easy and consumes REST APIs in Python. DevOps is built on APIs, by using this module developers can achieve tons of tasks! How to use it? First of all, requests is not a built-in Python library, it’s available on with more than 30 million downloads per week according to GitHub. PyPi To install on Linux, the command installs in the Python environment. requests $ python -m pip install requests It offers rich features such as: cookies support a wide range of HTTP Methods support a variety of authentication such as basic auth, Digest, OAuth … proxy supports Here is an example of how to send a simple request: import requests
apiUrl = 'https://webexapis.com/v1/rooms' 
access_token ='MTIwZDJmNGItOTFiNi00YmI5LTk4NzQtN2MyMzJhNDkxMDkzMGQzZDdiZDUtOWY4_PF84_3f179706-f11a-4ab7-ba3e-57a4a96b0892340s4ff'
httpHeaders = { 'Content-Type': 'application/json', 'Authorization': 'Bearer ' + access_token } 
body = { 'toPersonEmail':'tofrench@webex.bot' , 'text': 'welcome to the DevOps room ' }
response = requests.post( url = apiUrl, json = body, headers = httpHeaders )
print( response.status_code )
print( response.text ) The snippet shows how to import the requests module to send a message in a room using Webex APIs. Daily there is an interaction between clients and servers on the internet and different private networks around the globe, Api is the new CLI, and developers moving to DevOps should learn this module to work easily with their peers in testing and production environments, Apis are everywhere now. OS It provides functions for interacting with an operating system using local, remote, and cloud files. In the realm of DevOps/System admin, it is usual to interact with operating systems daily. In a nutshell, it uses the underlying operating system. By doing so, we can automate various tasks such as creating and removing directories, checking if a file or directory exists, managing environment variables, and process management. It offers rich features such as : Error handling Path manipulation File system access Process management here is an example of how to create a file : import os 
with open ("DataCenterLogs.py", "xt") as DT :
    DT.write("Hello DevOps admins, this is a new file,just created ")
    DT.close() The script creates a new file called in the current working directory. The mode in the open() function tells Python to create a new file if it does not already exist. The mode indicates that the file is a text file. DataCenterLogs.py x t One of our daily routines is to work with operating systems such as Mac OS, Windows, and Linux with its various distributions, Mastering the basics of the OS module and its functions is a must for DevOps engineers. The module is built-in, no need to install it in Python OS Sys The sys module in Python provides a plethora of functions and variables that are used to manipulate different parts of the Python runtime environment, a great way for DevOps engineers to retrieve important information about the system they are working on, such as where the code is running on, the python version they are using, the interpreter version and so much more … Some of the well-known features are : input and output command line arguments raising exceptions and controlling the flow of execution Here is an example of how to get information about the Python interpreter we use: import sys 
print(sys.version) The output should look like this: 3.7.16 (default, Dec  7 2022, 01:11:59)
[GCC 7.5.0] As one of the most important modules in Python, developers moving to DevOps should learn because every day we work in a testing environment before moving to production, they have to know the development environment they are working on, to work easily with the rest of their teams. The module is built-in, no need to install it in Python sys Beautiful soup This module helps us to extract information from websites, a process known as . Web Scraping The world behind the internet seems strange, network protocols and data formats are hidden in the transport and exchange of data while we enjoy browsing the web and using apps on our smartphones. It is useful for extracting data on web pages from HTML and XML documents, scraping websites, and automating tasks, in the DevOps realm It is also valuable for debugging and testing in a CI/CD pipeline. It offers rich features such as : Parse and documents HTML XML Extracting data from documents Modifying documents To install the module: pip3 install beautifulsoup4 After installing, we can test to import the module Beautiful soup as and the requests module : bs4 import bs4
import requests

def get_network_device_info(url, device_name):
    # Get the HTML content of the webpage.
    response = requests.get(url)
    html_content = response.content

    # Create a Beautiful Soup object from the HTML content.
    soup = bs4.BeautifulSoup(html_content, "html.parser")

    # Find the network device information.
    network_device_info = soup.find("table", class_="network-device-info")

    return network_device_info


def main():
    # Get the URL of the webpage.
    url = "https://www.TalesOfTechnology.com/network-devices"

    # Get the network devices.
    network_devices = get_network_devices(url)
    #iterates over the list of network devices 
    for network_device in network_devices:
        print(network_device)

if __name__ == "__main__":
    main() The code imports beautiful soup and then gets the content of a webpage using , which is useful for consuming REST APIs by sending HTTP requests  then it creates a beautiful soup object from the HTML content  and finds the network devices information. requests By writing this type of code we can automate the process of getting information about a specific network device from a web page and there are various tasks we can achieve beyond what we think with beautiful soup. In the world of testing and Automation, the goal is to reduce some manual tasks by automating a process, Developers should beautiful soup! Platform We live in a world of hardware and software, One of the usual tasks for developers is to work with operating systems of different flavors, with the module they can gather precious information about the OS and hardware they are using. It provides valuable information by identifying data such as the Python version, OS version, and CPU architecture. This module plays a major role for developers when they want to test if the hardware specification meets the requirement to use a program and if it is compatible with a Python version installed on a particular system. It offers rich features such as: Os information Hardware information Python version The module is built-in, no need to install it in Python Platform Here is a snippet of how to get the OS name : import platform  

#get the os name 

Os_Name = platform.system() 

print(Os_Name) The output should look like this: Linux The code imports the platform module and then uses the platform.system() function to get the operating system name, it returns the OS name . Linux how useful is the platform module? developers moving to DevOps should learn to simplify their work. Where do the modules fit in the DevOps Pipeline? Some engineers say DevOps is boring! 😀 The fact is it’s around processes and automation, In a pipeline, we have eight stages that combine the roles of two teams: Development and Operation, which is known as DevOps. In the , we have: Development phase Plan Build Code Test and in the : Operation phase Release Deploy Operate Monitor The modules requests, os, sys, beautiful soup, and platform are versatile and can be used in different phases of the pipeline, They are precious tools to help engineers gather information on systems, automate complex tasks, troubleshoot problems, and save time for more efficiency. Conclusion DevOps has changed the way we work now in the tech industry. It is not a technology but a philosophy, a culture, and a new way of doing things quickly by automating some processes, Python is the language of automation, and developers moving to the new culture should learn some modules to start their journey. To climb to the DevOps pyramid of success, it is always better to start with the basics; it is not possible to learn and master all the modules! It takes days and years to become a seasoned developer. The modules shown are not exhaustive, there is a plethora, The goal of this article was to show the most used modules you can encounter in your daily tasks once you start your journey. As soon as you grow, you will discover more. Go step by step with the basics for a successful journey, Rome was not built in a day!

Moving to DevOps? Discover 5 Python Modules to Shine in Your New Journey

The US Defense Advanced Research Projects Agency ( ) is looking to improve traumatic memory consolidation by modulating REM sleep for stress and trauma adaption. DARPA This month, DARPA issued a for a potential research program called “Rapid Eye Movement Restoration and Enhancement for Sleep-deprived Trauma Adaptation” ( ), which “ .” Disruption Opportunity REM REST aims to identify neural mechanisms and demonstrate the ability to modulate REM sleep that improves stress adaptation and traumatic memory consolidation “Targeted Dream Incubation may have applications as a learning tool that can improve memory consolidation” Science Alert, 2020 Connecting post-traumatic disorder (PTSD) with memory consolidation and REM, DARPA says that: stress “Disrupted REM […] is associated with post-traumatic stress disorder (PTSD) and impaired emotional memory consolidation.” Of particular interest to DARPA are “ .” novel applications of existing neuromodulation technologies to target REM sleep and demonstrate the ability to measure and enhance neural mechanisms of stress and trauma adaption According to an MIT Media Lab , “ .” study on dream engineering nearly any sensory stimuli has potential for modulating experience in sleep “We present a novel protocol using a new wearable electronic device, Dormio, to automatically generate serial auditory dream incubations at sleep onset, wherein targeted information is repeatedly presented during the hypnagogic period, enabling direct incorporation of this information into dream content, a process we call targeted dream incubation (TDI)” MIT Media Lab, 2020 Although DARPA’s makes no mention of dreams, the idea of modulating and even artificially implanting dreams is not far off. REM REST After all, most dreams occur during REM. In fact, MIT came up with a hand-wearable electronic device called “to automatically generate serial auditory dream incubations at sleep onset, wherein targeted information is repeatedly presented during the hypnagogic period, enabling direct incorporation of this information into dream content, a process we call (TDI).” Dormio targeted dream incubation While targeted dream incubation may be beyond the scope of , says that there is “a similar experimental method called (TMR), which reactivates specific memories that are triggered by a cue delivered during sleep,” which may prove interesting. REM REST Science Alert targeted memory reactivation For , DARPA is looking for proposals that can “evaluate the mechanistic relationship with stress adaptation, traumatic , and/or other related emotional h resilience outcomes.” REM REST memory consolidation ealth and psychological says that “ .” Science Alert TDI may have applications as a learning tool that can improve memory consolidation With that in mind, could targeted dream incubation like in the movie be among the proposals? Inception “Novel solutions to restoring and enhancing the mechanisms by which REM sleep promotes stress and trauma adaptation could provide important breakthroughs for treating sleep disturbances, improving overall sleep quality, and preventing PTSD and other behavioral health outcomes, such as suicide, associated with disrupted REM sleep” DARPA REM REST, 2023 The US Department of Veteran Affairs says that will experience post-traumatic stress disorder at some point in their lives. seven percent of veterans PTSD, according to some researchers, may be looked upon as a disorder of basic memory function. As one states, “Approaching PTSD as a memory disorder, with a specific focus on (re)consolidation opens up exciting, new ways to think about treatment.” study from 2015 And from the University of Tsukuba and the University of Tokyo recently revealed that “adult-born neurons (ABNs) in the hippocampus, which is a brain region associated with memory, are responsible for memory consolidation during REM sleep.” researchers For , the Pentagon’s research funding arm is looking towards “ ” as this “could provide important breakthroughs for treating sleep disturbances, improving overall sleep quality, and preventing PTSD and other behavioral health outcomes, such as suicide, associated with disrupted REM sleep.” REM REST novel solutions to restoring and enhancing the mechanisms by which REM sleep promotes stress and trauma adaptation Last year, under the premise of identifying people at risk of depression and suicide, the Pentagon’s research funding arm launched the , which focused on “aggregating preconscious brain signals to determine what someone believes to be true.” Neural Evidence Aggregation Tool ( NEAT ) program While mental health among soldiers is a serious issue for the Department of Defense, applications coming out of the program have the very real potential to give governments and corporations the ability to hack human beings at the preconscious level. NEAT This article was originally published by on Tim Hinchliffe The Sociable.

DARPA Seeks to Modulate REM Sleep for Stress and Trauma Adaptation

DARPA স্ট্রেস এবং ট্রমা অ্যাডাপ্টেশনের জন্য REM ঘুমকে সংশোধন করতে চায়

DARPA versucht, den REM-Schlaf zur Anpassung an Stress und Traumata zu modulieren

DARPA busca modular el sueño REM para la adaptación al estrés y al trauma

La DARPA cherche à moduler le sommeil paradoxal pour l'adaptation au stress et aux traumatismes

DARPA तनाव और आघात अनुकूलन के लिए REM नींद को संशोधित करना चाहता है

DARPAはストレスとトラウマの適応のためにレム睡眠を調節することを目指す

DARPA는 스트레스와 트라우마 적응을 위해 REM 수면을 조절하려고 합니다.

DARPA procura modular o sono REM para adaptação ao estresse e trauma

DARPA, Stres ve Travmaya Uyum için REM Uykusunu Düzenlemeyi Amaçlıyor

DARPA tìm cách điều chỉnh giấc ngủ REM để thích ứng với căng thẳng và chấn thương

DARPA 寻求调节快速眼动睡眠以适应压力和创伤

The Noonification: Building Efficient npm Packages with React, TypeScript, and CSS Modules: A Comprehensive Guide (7/15/2023)

Creating reusable npm packages can make your development process more efficient and enjoyable. In this article, we'll guide you through creating a modern and robust project setup using React, TypeScript, CSS Modules, and other tools. Before we start, you can find the source code here: . This repository serves as a base for creating npm packages using React and TypeScript. It's preconfigured with a build process and a set of recommended packages for a modern development workflow. https://github.com/helgastogova/npm-react-typescript-template The key features include: : Modern UI development with strong type safety and a superior developer experience. React & TypeScript : Styling components in isolation, avoiding CSS conflicts, and enabling modular design. CSS Modules : Ensuring code quality by adhering to JavaScript and React's best practices. ESLint : Efficiently bundling React and TypeScript code into a single file for distribution. Rollup : Utilizing next-gen CSS features and handling browser compatibility. PostCSS : Monitoring your library's size and preventing accidental size bloat. Size Limit Let's dive into each tool more comprehensively. CSS Modules CSS modules serve as a beacon of safety in the realm of styling chaos. They implement local scoping for your styles, warding off conflicts and overlap issues. Each CSS module will be "encapsulated" into the component, ensuring the styles you define won't leak out and affect other elements unintentionally. Consider this simple component where we use CSS Module: // TestComponent.tsx

import React from 'react';
import s from './TestComponent.module.css';

type TestComponentProps = {
  text?: string;
};

export const TestComponent: React.FC<TestComponentProps> = ({ text }) => {
  return <div className={s.root}>{text ?? 'Hello!'}</div>;
}; And its associated CSS Module: /* TestComponent.module.css */

.root {
  background-color: pink;
  padding: 20px;
  border-radius: 8px;
} In this case, the class from won't affect any other class in a different module. .root TestComponent.module.css .root ESLint is like a lighthouse guiding you through a tumultuous sea of code. It helps maintain code quality, catching errors and enforcing best coding practices before they become problems. ESLint In your , you have: package.json "scripts": {
  "lint": "eslint './src/**/*.{ts,tsx}'"
} Run the linter with . ESLint will scan through your TypeScript files and warn you about any potential issues. This is particularly handy for large codebases where it's easy for small errors or inconsistencies to creep in. npm run lint Rollup is your code's personal fitness trainer. It takes your JavaScript, TypeScript, and CSS and bundles them into one lean, efficient package ready for distribution. Rollup It's lightweight and fast, but the real benefit comes from its "tree-shaking" capability. Rollup can eliminate unused code from the final bundle, making your package as lean as possible. Here's an example of how your Rollup configuration might look: // rollup.config.js

const postcss = require('rollup-plugin-postcss');
const typescript = require('@rollup/plugin-typescript');
const peerDepsExternal = require('rollup-plugin-peer-deps-external');
const resolve = require('@rollup/plugin-node-resolve').default;
const commonjs = require('@rollup/plugin-commonjs');

module.exports = {
  input: 'src/index.tsx',
  output: {
    dir: 'dist',
    format: 'cjs',
    sourcemap: true,
  },
  plugins: [
    peerDepsExternal(),
    resolve(),
    typescript(),
    commonjs(),
    postcss({
      modules: true,
    }),
  ],
}; PostCSS is like a time-traveler, allowing you to write CSS using future syntax and features. It then travels back in time (so to speak), transforming these modern styles into code that even older browsers can understand. PostCSS You can see PostCSS in action in the Rollup configuration above. Using the , your modern CSS is transformed and included in your final bundle. The beauty of this is that you can write CSS using the latest features without worrying about browser compatibility. rollup-plugin-postcss Size Limit is the ever-vigilant watchman, making sure your library doesn't get too bloated. It calculates the real cost of your library by adding both the JavaScript and CSS that will be downloaded by users. It's a valuable tool to help you keep your bundle size in check. Size Limit In your : package.json "scripts": {
  "size": "size-limit",
},
"size-limit": [
  {
    "path": "dist/*.js",
    "limit": "10 KB"
  }
] You can then run to check the size of your bundle. If it exceeds the limit you've set (in this case, 10 KB), the script will throw an error. It's a great way to ensure you're not unknowingly adding to your users' download times. npm run size Setup To start using this template, clone the repository: git clone https://github.com/helgastogova/npm-react-typescript-template.git Navigate into the directory: cd npm-react-typescript-template Install the dependencies: npm install You're all set to start developing your package! The entry point is src/index.tsx Building the Package After creating your own component and when you're ready to build your package for distribution, run: npm run build Your built package will be in the directory, ready for publishing to npm. dist Publishing to npm Ensure that you've set the field in your to your desired package name. Also, remember to update the version number before each new publish. Once that's done, log in to npm using: name package.json npm login Enter your username, password, and email. Once logged in, you can publish your package with: npm publish Now you have published your component in the , and people can start using it. You are awesome! npmjs library Happy coding!

Building Efficient npm Packages with React, TypeScript, and CSS Modules: A Comprehensive Guide

প্রতিক্রিয়া, টাইপস্ক্রিপ্ট এবং সিএসএস মডিউল সহ দক্ষ এনপিএম প্যাকেজ তৈরি করা: একটি ব্যাপক নির্দেশিকা

Erstellen effizienter npm-Pakete mit React-, TypeScript- und CSS-Modulen: Ein umfassender Leitfaden

Creación de paquetes npm eficientes con módulos React, TypeScript y CSS: una guía completa

Création de packages npm efficaces avec les modules React, TypeScript et CSS : un guide complet

रिएक्ट, टाइपस्क्रिप्ट और सीएसएस मॉड्यूल के साथ कुशल एनपीएम पैकेज बनाना: एक व्यापक गाइड

React、TypeScript、CSS モジュールを使用した効率的な npm パッケージの構築: 包括的なガイド

React, TypeScript 및 CSS 모듈을 사용하여 효율적인 npm 패키지 구축: 종합 가이드

Construindo pacotes npm eficientes com módulos React, TypeScript e CSS: um guia completo

React, TypeScript ve CSS Modülleriyle Verimli npm Paketleri Oluşturma: Kapsamlı Bir Kılavuz

Xây dựng các gói npm hiệu quả với các mô-đun React, TypeScript và CSS: Hướng dẫn toàn diện

使用 React、TypeScript 和 CSS 模块构建高效的 npm 包：综合指南

Welcome to our guide on building a hardware-software Geiger counter emulator of module based on ESP8266 This emulator can be useful for testing and tuning Geiger counters or for educational purposes. Let’s get started! GGreg20_V3 When writing this article, we decided to make a separate commercial product – the Geiger counter emulator . Updated: GCemu20_V1 Part 1: Introduction and Overview It is known that the Espressif ESP8266 module has a very high quality random number generator. We could not find any official details about the actual implementation of this generator, so we propose to read the material on this subject, published by a radio amateur and saved on the Internet: https://web.archive.org/web/20170321162556/http://esp8266-re.foogod.com/wiki/Random_Number_Generator Two different concepts with the same name are used in the text. Historically, there is a NodeMCU hardware module on the market as well as NodeMCU software firmware. The NodeMCU firmware is a compilable, open-source microprogram that can be written to hardware modules with Espressif’s ESP8266 controller. One of the many products based on the ESP8266 controller, is the NodeMCU hardware module. Thus the NodeMCU firmware can be written to the NodeMCU hardware module. Later in this article we will try, if possible, to clarify what is meant by the name NodeMCU: module or firmware. What is a Geiger counter emulator for Before proceeding to create a Geiger counter emulator, it is necessary to consider what for and who may need such a hardware-software device. The main idea of any emulator in the field of DIY electronics is to temporarily, at certain stages, use a virtual substitute component instead of a real module in the process of IoT device development or experimenting / learning to reproduce the operation and characteristics of a real device with high accuracy. The emulator should simplify and speed up development, as well as add convenience in the initial stages of a planned project or performing unit tests. Below we present some theses explaining our motives for developing the GGreg20_V3 Geiger counter module emulator. 1. No high voltage The GGreg20_V3 emulator, unlike the real module, has no high voltage on the board, so it is very convenient to use when developing on the table without fear of accidental electrocution. At the same time, in terms of the electrical interface of the outgoing pulses, the emulator is a completely similar radiation sensor module, generating random pulses of the same shape and duration as the genuine GGreg20_V3. 2. Simplified learning process The Geiger counter emulator is suitable for educational institutions. The instructor can gradually deepen practical lessons with students. First, all classes can be conducted using safe and cheap Geiger counter emulators, and then with real modules with Geiger tubes and high voltage on the tube side. Just like in the Army: familiarization and training is done first with blank cartridges, and only then with live ones. The emulator fully reproduces the results of the real GGreg20_V3 module, so there is no problem of insufficient number of real modules in the classroom: each student can work with his module independently and complete the learning process without dividing into groups or queues, as it usually happens when resources of training devices and stands in the lab are limited. 3. Lower cost The emulator has a lower cost than the real GGreg20_V3 module, so it is convenient to use it primarily for debugging and harmonizing the circuit or software of the system being designed or studied. Debugging a test bench or a project with such an emulator can be performed without the need for specially qualified personnel. If the emulators are used by students, then the teacher will not need to control the work with the devices, as would be necessary to do with the real Geiger counter module. Low-cost emulators can be purchased in large quantities and given to students for the duration of their studies, not just for the time they work in the school’s laboratory. 4. No real source of radiation is needed When we work with a real GGreg20_V3, we need a true source of radiation to reproduce the various situations that need to be considered in the software of the measurement system that is being designed or tested. In order to buy a test radiation source, the radio amateur must first solve a number of problems: to determine by physical and chemical parameters which source is needed; to find a supplier and buy a test source; some countries require customs notification and an import permit; the test source can only be of a certain power; you must properly store and dispose of the radioactive source; the price of the radiation source and its storage system exceeds many times the price of the Geiger counter. With the emulator, none of these problems will occur. The device can simulate 5 different modes of ionizing radiation power. The Geiger counter emulator generates output pulses similar to those of the real GGreg20_V3 module in the range from 0 to 1.5 µSv/h (taking the SBM-20 tube as a similar reference). At the output are generated chaotic (using a true random number generator ESP8266) pulses of the same amplitude with a total pulse period of 10 microseconds each. 5. Emulator resource cannot be depleted SBM-20 tube, installed in GGreg20_V3, has a relatively large, but still limited resource of particles, which it can detect during its lifetime. The resource of the SBM-20 tube declared in the documentation is at least 2*1010 pulses. . With a background radiation of 0.15 μSv/h with a coefficient of 0.0057, the SBM-20 tube detects about 27 pulses per minute. Note 1 Thus, under normal conditions, the resource of the tube will be enough for 2*1010 / (27 * 60 * 24) = 20 000 000 000 / (26 * 60 * 24) = 514403 days. And it would seem that this is quite a sufficient potential life of one tube. A completely different picture is observed when it comes to operating a tube with a test source of radiation. Here’s an example: On its website, Images Scientific Instruments provides a list of the radiation limits allowed for import for test sources: https://www.imagesco.com/geiger/radioactive-sources-int.html Let’s take two sources from the list at the link: Co-60 1.00 uCi, 37000 Bq; Cs-137 0.25 uCi, 9250 Bq; If we assume that under the influence of such a test source, half of the particles from radioactive decays enter the Geiger tube SBM-20 then the lifetime of such a tube would be: 20 000 000 000 / (37000 / 2 * 60 * 60 * 24) = 12 days (for Co-60); 20 000 000 000 / (9250 / 2 * 60 * 60 * 24) = 50 days (for Cs-137). As you can see, if we want to experiment (or test our devices that include a Geiger counter) on a real tube, then we deplete its available resource with a true source of radiation rather quickly. There is no such problem with the emulator. Using the emulator first instead of the tube is economically feasible. 6. Debugging data in the UART The emulator of GGreg20_V3 module outputs operational data (pulses, time, counts, cycles, etc.) to the UART console port during operation, which, if necessary, can be recorded and processed by the student, developer or radio amateur for training or comparison with the measurements of his tested or developed system. Genuine GGreg20_V3 counter modules and similar modules of other manufacturers do not and cannot have such a built-in feature. . To connect to the UART console, the , on which the emulator is based, has separately led UART interface lines (2.54 mm pitch holes for soldering) on the PCB. To connect the emulator to the computer the user additionally needs to have his own USB-UART converter. Note 2 ESP12.OLED module Further in the text the connection diagram will be given. Also published . here

Geiger Counter Emulator of GGreg20_V3 Module by Means of ESP8266 (Part 1 of 3)

Emulador de contador Geiger del módulo GGreg20_V3 por medio de ESP8266 (Parte 1 de 3)

Émulateur de compteur Geiger du module GGreg20_V3 au moyen d'ESP8266 (partie 1 sur 3)

ESP8266 के माध्यम से GGreg20_V3 मॉड्यूल का गीगर काउंटर एमुलेटर (3 का भाग 1)

ESP8266 による GGreg20_V3 モジュールのガイガー カウンター エミュレーター (パート 1/3)

Emulador de contador Geiger do módulo GGreg20_V3 por meio de ESP8266 (parte 1 de 3)

Trình giả lập bộ đếm Geiger của Mô-đun GGreg20_V3 bằng ESP8266 (Phần 1/3)

使用 ESP8266 的 GGreg20_V3 模块的盖革计数器仿真器（第 1 部分，共 3 部分）

Passing and Returning Structured Datatypes to and From Go WebAssembly Module

The kernel is a free and open-source project that is similar to the Unix-like operating systems. The Linux kernel was created by Linus Torvalds in 1991. Linux The Linux kernel manages system resources, creates and destroys processes, manages memory, and provides communication between software and hardware, such as CPU, memory, and I/O devices, etc. One of the great features of the Linux kernel is its ability to support the loading/unloading of kernel modules. It could be drivers or modules which can be loaded and unloaded at runtime, without the need to reboot the system. Writing your first kernel module can be an exciting and rewarding experience. Getting Started With Your First Kernel Module Before you start writing your first kernel module, you need to make sure that you have a kernel development environment. This typically involves installing a set of tools and libraries, including the kernel headers and development packages. Remember it could be different in other systems. These examples have been done in but it’s similar in other distributions. Ubuntu 20.04 $ sudo apt update && sudo apt upgrade First, let’s update and upgrade the system $ sudo apt-get install gcc make build-essential libncurses-dev exuberant-ctags build-essential linux-headers-`uname -r` This will install the essential development tools and the kernel headers necessary for this example. Once you have your development environment set up, you can begin writing your kernel module. Here's a basic example of a kernel module that simply prints a message to the system log when it is loaded and unloaded, let's create a file and add the below content in there. hello.c #include <linux/init.h> #include <linux/kernel.h> #include <linux/module.h> MODULE_LICENSE("GPL"); static int __init module_start(void) { printk(KERN_INFO "Hello, World!\n"); return 0; } static void __exit module_end(void) { printk(KERN_INFO "Goodbye, World!\n"); } module_init(module_start); module_exit(module_end); #include <linux/init.h>: This line includes the header file for kernel initialization functions, which are needed to set up the module. #include <linux/kernel.h>: This line includes the header file for kernel functions, which are needed to perform actions such as printing messages to the kernel log. #include <linux/module.h>: This line includes the header file for kernel modules, which are used to add functionality to the kernel. MODULE_LICENSE("GPL");: This line sets the license for the module to the GNU General Public License (GPL). This is required for all kernel modules. static int __init module_start(void): This line defines the initialization function for the module, which will be called when the module is loaded into the kernel. The "__init" keyword tells the kernel to discard this function after it is called, to save memory. printk(KERN_INFO "Hello, World!\n");: This line uses the printk() function to print the message "Hello, World!" to the kernel log, using the KERN_INFO priority level. return 0;: This line returns 0 to indicate that the initialization function has been completed successfully. static void __exit module_end(void): This line defines the cleanup function for the module, which will be called when the module is unloaded from the kernel. The "__exit" keyword tells the kernel to discard this function after it is called, to save memory. printk(KERN_INFO "Goodbye, World!\n");: This line uses the printk() function to print the message "Goodbye, World!" to the kernel log, using the KERN_INFO priority level. module_init(module_start);: This line registers the initialization function with the kernel, so that it will be called when the module is loaded. module_exit(module_end);: This line registers the cleanup function with the kernel, so that it will be called when the module is unloaded. To compile this module, you will need to create a Makefile that specifies the module name and source files. Here's an example Makefile: obj-m += hello.o all: make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules clean: make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean This Makefile will build a kernel module named hello.o from the source file hello.c. To build the module, simply run in the directory containing the Makefile. If everything goes well, you should see a file generated, which is the compiled kernel module. Also you can use make clean for clean directory and remove generated files make hello.ko This line specifies a target called "all", which is the default target when no specific target is specified. The target "all" will build the kernel module. all: This line specifies a target called "clean", which will clean up any files created during the build process. clean: To load the module, use the command: insmod $ sudo insmod hello.ko To unload the module, use the command: rmmod $ sudo rmmod hello.ko You can check the system log using the command or check the /var/log/syslog log file to see the messages printed by the module: dmesg $ dmesg | grep World [566458.370280] Hello, World! [566490.188611] Goodbye, World! Final Thoughts In conclusion, writing a Linux kernel module can be a challenging but rewarding experience. Kernel module development requires some basic understanding of the Linux operating system and command line, as well as some base knowledge of C programming language. However, once you have mastered the basics, you can start programming Linux kernel modules and drivers which can be used for various spheres. In this article, we have covered the essential steps required to create a simple "Hello, World!" kernel module. We use Linux Ubuntu 20.04 and started by setting up the development environment by installing the necessary packages. Then, we explored the simple structure of a Linux kernel module. We also compiled and loaded the basic module into the Kernel by using command, and unload by using command. insmod rmmod What did you think of this guide? Please let me know in the comments below and follow me on HackerNoon for more guides like this! Resources The Linux Kernel Module Programming Guide The lead image for this article was generated with Kadinsky 2 on HackerNoon. Prompt: Linux kernel holding kernels

How to Write Your First Linux Kernel Module

When studying Python, you inevitably face the problem of choosing between static methods ( ), class methods ( ), and functions. In this article, I would like to deal with this issue. @staticmethod @classmethod module-level From a technical point of view, the only difference between static and class methods is that the class method gets the class as the first argument. Consider a simple example: class Number:

    def __init__(self, value):
        self.value = value

    @classmethod
    def multiply(cls, x, y):
        return cls(x*y)

    @staticmethod
    def divide(x, y):
        return Number(x // y) In this example, the Number class has two methods: a class method and a static one . And we can successfully call both of these methods and it will all work. multiply divide >>> n = Number.multiply(1, 2)
>>> n.print()
2
>>> type(n)
<class '__main__.Number'>

>>> n = Number.divide(2, 1)
>>> n.print()
2

>>> type(n)
<class '__main__.Number'> But what will happen if an inheritance is used? For example: class Real(Number):
    pass The class will inherit all the methods of , but when we access the method, we will not get exactly what we might expect. Real Number divide >>> r = Real.multiply(1, 2)
>>> r.print()
2
>>> type(r)
<class '__main__.Real'>

>>> r = Real.divide(2, 1)
>>> r.print()
2
>>>type(r)
<class '__main__.Number'> As we can see, the method will return a instance instead of . To solve this problem, -s are just right. divide Number Real @classmethod class Number:

    def __init__(self, value):
        self.value = value

    @classmethod
    def divide(cls, x, y):
        return cls(x // y)

    def print(self):
        print(self.value)


class Real(Number): pass >>> r = Real.divide(2, 1)
>>> r.print()
2

>>>type(r)
<class '__main__.Real'> So when is it better to use a class method, when a static method, and when a module-level function? I believe that if a function needs access to a class, then it is a class method, if it does not need access to either the class or an instance of the class, but is logically related to the class, then it is a static method, otherwise, it is a module-level function.

Python @classmethod vs @staticmethod vs Module-level Functions

Building a Better Blockchain: Lessons in Innovation and Adoption

Colliding Magnetospheres in The Young High-Eccentricity Binary DQ Tau: Discussion

This paper is available on arxiv under CC 4.0 license.
Authors:
(1) Konstantin V. Getman, Department of Astronomy & Astrophysics, Pennsylvania State University;
(2) Agnes Kospal, Konkoly Observatory, Research Centre for Astronomy and Earth Sciences, E¨otv¨os Lor´and Research Network (ELKH), MTA Centre of Excellence, Max Planck Institute for Astronomy, and ELTE E¨otv¨os Lor´and University, Institute of Physics;
(3) Nicole Arulanantham, Space Telescope Science Institute;
(4) Dmitry A. Semenov, Konkoly Observatory, Research Centre for Astronomy and Earth Sciences;
(5) Grigorii V. Smirnov-Pinchukov, Konkoly Observatory, Research Centre for Astronomy and Earth Sciences;
(6) Sierk E. van Terwisga, Konkoly Observatory, Research Centre for Astronomy and Earth Sciences. Table of Links Abstract and Intro
X-ray Observations and Data Extraction
Flare Analyses
Comparison with X-ray Flares from Young Stars
Discussion
Conclusions
Acknowledgments and References 2. X-RAY OBSERVATIONS AND DATA EXTRACTION 2.1. NuSTAR Data We conducted a single observation (ObsID 30801011002; PI K. Getman) of this system with NuSTAR (Harrison et al. 2013) from 04:51:09 UTC on July 28, 2022, to 19:36:09 UTC on July 31, 2022. This time window covers the orbital phase range of Φ = (0.9 − 1.13) around the periastron passage on July 30, 2022 (Φ = 1.0). The science exposure of the observation, taking into account Earth occultations, is 156 ksec. The data obtained from focal plane modules A and B (FPMA and FPMB), covering similar energy ranges, were processed using tools from the NuSTAR Data Analysis Software package NuSTARDAS (v. 2.1.2), which is incorporated into HEASOFT (v. 6.31.1) as detailed in (Nasa High Energy Astrophysics Science Archive Research Center (Heasarc) 2014). NuSTAR’s calibration database (CALDB) v. 20221229 was utilized. The data went through calibration and screening using the nupipeline tool. Parameters saamode=OPTIMIZED and tentacle=yes were employed to screen the data for elevated count rates resulting from the spacecraft’s passages through the South Atlantic Anomaly. Subsequently, the nuproducts tool was utilized to generate various outputs, including the source and background lightcurves and spectra, as well as response and response matrix files. Figures 1(a,b) present images of the combined FPMA and FPMB event lists for the (3 − 10) keV and (10 − 50) keV energy bands, respectively. The source counts were obtained from a circular region with a radius of 40′′ (indicated by the green circle in Figure 1), representing 60% of the energy within the point spread function. The background measurement was performed locally in an area devoid of sources. Within the source extraction circle, there are 771 X-ray events with energies ranging from 3 to 10 keV, approximately one third of which are background events. The source is not detected in the (10 − 20) keV band (not shown) or the (10 − 50) keV band (Figure 1b), nor at higher energies. 2.2. Swift Data Using the Neil Gehrels Swift observatory (Gehrels et al. 2004), we conducted 16 short observations of DQ Tau near periastron over a time period of July 28 to August 2, 2022. These observations are part of our joint NuSTAR/Swift program. The observations were spaced several hours apart, with durations ranging from 1 to 1.7 ksec, totaling 22.5 ksec. The target ID for these observations is 14857. The X-ray Telescope (XRT) operated in the PC mode, while the Ultraviolet/Optical Telescope (UVOT) operated in the 0x30ed standard sixfilter blue-weighted mode. The Swift-XRT data product generator (Evans et al. 2007, 2009) was utilized to construct X-ray light curves and source/background spectra, along with the relevant calibration files. The generator employed HEASOFT package (v. 6.29) and CALDB (v. 20230109). Figure 1c presents the XRT image obtained from merging the event lists of all 16 observations. Within the circular source extraction region of a 30′′ radius (indicated by the green circle in the image), we identified 249 X-ray counts with energies ranging from 0.2 to 10 keV, of which only a few percent represented background counts. For each of the 16 observations, UVOT magnitudes for the six filters (V:B:U:W1:M2:W2) were measured by applying the fappend (Blackburn et al. 1999) and uvotmaghist tools from HEASOFT (v. 6.31.1). 2.3. Chandra Data To investigate the soft X-ray emission throughout the entire orbital phase of DQ Tau and complement the observations made by NuSTAR and Swift at periastron, additional X-ray data were obtained utilizing the Chandra X-ray Observatory (Weisskopf et al. 2002). The investigation involved 12 short Chandra imaging observations of DQ Tau away from periastron, with each observation lasting approximately 1.5 ksec. These observations were part of the Director’s Discretionary Time (DDT) program, with corresponding observation IDs ranging from 26464 to 26475. Data were obtained between August 1 and August 14, 2022, covering an orbital phase range of 1.1 to 1.9. To mitigate potential pileup effects during anticipated Xray flares, a 1/8 sub-array of a single ACIS-I3 chip was employed (Garmire et al. 2003). For the Chandra data reduction and analysis, CIAO v4.15(Fruscione et al. 2006) and CALDB v4.10.4 were utilized. The CIAO tools chandra repro and reproject obs were used to reprocess the data and merge the event images. Figure 1d displays the cutout of the merged Chandra-ACIS-I3 image of DQ Tau. Count rates and apparent fluxes were measured, and spectra and response files were generated using the srcflux tool. Within the circular source extraction region, with a radius of 2′′ (indicated by the green circle in the image), and within the energy band of (0.5 − 8) keV, net X-ray events were observed between 30 and 50 per observation in 8 instances. However, the remaining 4 consecutive observations (ObsIDs 26471, 26472, 26473, and 26474) exhibited higher net count levels, ranging from 61 to 781 counts per observation. This paper is available on arxiv under CC 4.0 license. Authors: (1) Konstantin V. Getman, Department of Astronomy & Astrophysics, Pennsylvania State University; (2) Agnes Kospal, Konkoly Observatory, Research Centre for Astronomy and Earth Sciences, E¨otv¨os Lor´and Research Network (ELKH), MTA Centre of Excellence, Max Planck Institute for Astronomy, and ELTE E¨otv¨os Lor´and University, Institute of Physics; (3) Nicole Arulanantham, Space Telescope Science Institute; (4) Dmitry A. Semenov, Konkoly Observatory, Research Centre for Astronomy and Earth Sciences; (5) Grigorii V. Smirnov-Pinchukov, Konkoly Observatory, Research Centre for Astronomy and Earth Sciences; (6) Sierk E. van Terwisga, Konkoly Observatory, Research Centre for Astronomy and Earth Sciences. This paper is available on arxiv under CC 4.0 license. Authors: Authors: (1) Konstantin V. Getman, Department of Astronomy & Astrophysics, Pennsylvania State University; (2) Agnes Kospal, Konkoly Observatory, Research Centre for Astronomy and Earth Sciences, E¨otv¨os Lor´and Research Network (ELKH), MTA Centre of Excellence, Max Planck Institute for Astronomy, and ELTE E¨otv¨os Lor´and University, Institute of Physics; (3) Nicole Arulanantham, Space Telescope Science Institute; (4) Dmitry A. Semenov, Konkoly Observatory, Research Centre for Astronomy and Earth Sciences; (5) Grigorii V. Smirnov-Pinchukov, Konkoly Observatory, Research Centre for Astronomy and Earth Sciences; (6) Sierk E. van Terwisga, Konkoly Observatory, Research Centre for Astronomy and Earth Sciences. Table of Links Abstract and Intro X-ray Observations and Data Extraction Flare Analyses Comparison with X-ray Flares from Young Stars Discussion Conclusions Acknowledgments and References Abstract and Intro Abstract and Intro X-ray Observations and Data Extraction X-ray Observations and Data Extraction Flare Analyses Flare Analyses Comparison with X-ray Flares from Young Stars Comparison with X-ray Flares from Young Stars Discussion Discussion Conclusions Conclusions Acknowledgments and References Acknowledgments and References 2. X-RAY OBSERVATIONS AND DATA EXTRACTION 2.1. NuSTAR Data We conducted a single observation (ObsID 30801011002; PI K. Getman) of this system with NuSTAR (Harrison et al. 2013) from 04:51:09 UTC on July 28, 2022, to 19:36:09 UTC on July 31, 2022. This time window covers the orbital phase range of Φ = (0.9 − 1.13) around the periastron passage on July 30, 2022 (Φ = 1.0). The science exposure of the observation, taking into account Earth occultations, is 156 ksec. The data obtained from focal plane modules A and B (FPMA and FPMB), covering similar energy ranges, were processed using tools from the NuSTAR Data Analysis Software package NuSTARDAS (v. 2.1.2), which is incorporated into HEASOFT (v. 6.31.1) as detailed in (Nasa High Energy Astrophysics Science Archive Research Center (Heasarc) 2014). NuSTAR’s calibration database (CALDB) v. 20221229 was utilized. The data went through calibration and screening using the nupipeline tool. Parameters saamode=OPTIMIZED and tentacle=yes were employed to screen the data for elevated count rates resulting from the spacecraft’s passages through the South Atlantic Anomaly. Subsequently, the nuproducts tool was utilized to generate various outputs, including the source and background lightcurves and spectra, as well as response and response matrix files. Figures 1(a,b) present images of the combined FPMA and FPMB event lists for the (3 − 10) keV and (10 − 50) keV energy bands, respectively. The source counts were obtained from a circular region with a radius of 40′′ (indicated by the green circle in Figure 1), representing 60% of the energy within the point spread function. The background measurement was performed locally in an area devoid of sources. Within the source extraction circle, there are 771 X-ray events with energies ranging from 3 to 10 keV, approximately one third of which are background events. The source is not detected in the (10 − 20) keV band (not shown) or the (10 − 50) keV band (Figure 1b), nor at higher energies. 2.2. Swift Data Using the Neil Gehrels Swift observatory (Gehrels et al. 2004), we conducted 16 short observations of DQ Tau near periastron over a time period of July 28 to August 2, 2022. These observations are part of our joint NuSTAR/Swift program. The observations were spaced several hours apart, with durations ranging from 1 to 1.7 ksec, totaling 22.5 ksec. The target ID for these observations is 14857. The X-ray Telescope (XRT) operated in the PC mode, while the Ultraviolet/Optical Telescope (UVOT) operated in the 0x30ed standard sixfilter blue-weighted mode. The Swift-XRT data product generator (Evans et al. 2007, 2009) was utilized to construct X-ray light curves and source/background spectra, along with the relevant calibration files. The generator employed HEASOFT package (v. 6.29) and CALDB (v. 20230109). Figure 1c presents the XRT image obtained from merging the event lists of all 16 observations. Within the circular source extraction region of a 30′′ radius (indicated by the green circle in the image), we identified 249 X-ray counts with energies ranging from 0.2 to 10 keV, of which only a few percent represented background counts. For each of the 16 observations, UVOT magnitudes for the six filters (V:B:U:W1:M2:W2) were measured by applying the fappend (Blackburn et al. 1999) and uvotmaghist tools from HEASOFT (v. 6.31.1). 2.3. Chandra Data To investigate the soft X-ray emission throughout the entire orbital phase of DQ Tau and complement the observations made by NuSTAR and Swift at periastron, additional X-ray data were obtained utilizing the Chandra X-ray Observatory (Weisskopf et al. 2002). The investigation involved 12 short Chandra imaging observations of DQ Tau away from periastron, with each observation lasting approximately 1.5 ksec. These observations were part of the Director’s Discretionary Time (DDT) program, with corresponding observation IDs ranging from 26464 to 26475. Data were obtained between August 1 and August 14, 2022, covering an orbital phase range of 1.1 to 1.9. To mitigate potential pileup effects during anticipated Xray flares, a 1/8 sub-array of a single ACIS-I3 chip was employed (Garmire et al. 2003). For the Chandra data reduction and analysis, CIAO v4.15(Fruscione et al. 2006) and CALDB v4.10.4 were utilized. The CIAO tools chandra repro and reproject obs were used to reprocess the data and merge the event images. Figure 1d displays the cutout of the merged Chandra-ACIS-I3 image of DQ Tau. Count rates and apparent fluxes were measured, and spectra and response files were generated using the srcflux tool. Within the circular source extraction region, with a radius of 2′′ (indicated by the green circle in the image), and within the energy band of (0.5 − 8) keV, net X-ray events were observed between 30 and 50 per observation in 8 instances. However, the remaining 4 consecutive observations (ObsIDs 26471, 26472, 26473, and 26474) exhibited higher net count levels, ranging from 61 to 781 counts per observation.

Stories, News & Mentions about MODULIZE

Modulize’s Stories on HackerNoon