Tapply

tapply

In this tutorial, we will continue implementing an extension for the Criteria API using the Builder pattern and JPA Static Metamodel Generator. Please check the previous parts: Improving your experience with Criteria API using Builder pattern and JPA Static Metamodel - Part I Improving your experience with Criteria API using Builder pattern and JPA Static Metamodel - Part II In this chapter, we provide the (subquery) operator, for example: IN List<Order> ordersToSpainWithActiveMembership = criteriaApiHelper.select(Order.class)
 .in(Order_.customer,
 subquery(CustomerMembership.class)
 .isTrue(CustomerMembership_.isActive)
 .select(CustomerMembership_.customer),
 subquery(CustomerAddress.class)
 .equal(CustomerAddress_.country, Country_.name, "Spain")
 .select(CustomerAddress_.customer)
 )
 .findAll(); This query should fetch orders for the customers matching two subqueries: the customers with an active membership and the customers who live in Spain. 1. SubqueryPredicate First of all, to store the details, we define the interface. It will help us to construct the the same way as , which we created earlier to construct the : javax.persistence.criteria.Subquery SubqueryPredicate javax.persistence.criteria.Subquery QueryPredicate javax.persistence.criteria.Predicate @FunctionalInterface
public interface SubqueryPredicate {
 Subquery apply(CommonAbstractCriteria criteria, CriteriaBuilder cb);
} 2. SubQuery In this step, we create the interface to be able to filter the subquery using predicates methods from the inheriting interface: SubQuery BaseQuery public interface SubQuery<R, Q extends SubQuery<R, Q>> extends BaseQuery<R, Q> {
} Then after we provided the necessary filters with methods, in order to finish a subquery, we may need to specify the custom subquery’s path to select that will be used for the operator. BaseQuery IN For example, with the following method, we can select the entity from the root entity type: select() Customer CustomerAddress subquery(CustomerAddress.class)
 .equal(CustomerAddress_.country, Country_.name, "Spain")
 .equal(CustomerAddress_.city, City_.name, "Madrid")
 .select(CustomerAddress_.customer) Let’s provide the necessary methods with a different set of a parent-child relations chain, returning the instance, which we can use later to construct the : select() SubqueryPredicate javax.persistence.criteria.Subquery public interface SubQuery<R, Q extends SubQuery<R, Q>> extends BaseQuery<R, Q> {
 SubqueryPredicate<R> select();

 SubqueryPredicate select(SingularAttribute<R, P> attribute);

 <P1, P2> SubqueryPredicate<P2> select(SingularAttribute<R, P1> attribute1, SingularAttribute<P1, P2> attribute2);

 <P1, P2, P3> SubqueryPredicate<P3> select(SingularAttribute<R, P1> attribute1, SingularAttribute<P1, P2> attribute2, SingularAttribute<P2, P3> attribute3);
} Next, let’s create the implementation of the interface, and implement the defined methods: SubQuery select() public class SubQueryImpl<R> extends BaseQueryImpl<R, SubQueryImpl<R>> implements SubQuery<R, SubQueryImpl<R>> {
} When we construct a subquery, first we specify the Root type as the entity that we use to start a query from. Therefore, the constructor should accept the Root type: public class SubQueryImpl<R> extends BaseQueryImpl<R, SubQueryImpl<R>> implements SubQuery<R, SubQueryImpl<R>> {
 private final Class<R> type;

 public SubQueryImpl(Class<R> type) {
 this.type = type;
 }

 @Override
 protected SubQueryImpl<R> self() {
 return this;
 }
} Next, we implement the defined methods. Each method should return an instance of : select() SubqueryPredicate new SubqueryPredicate<R>() {
 @Override
 public Subquery<R> apply(CommonAbstractCriteria criteria, CriteriaBuilder cb) {
 Subquery<R> subquery = criteria.subquery(type);
 Root<R> subqueryRoot = subquery.from(type);
 subquery
 .select(subqueryRoot)
 .where(buildPredicates(subquery, predicates, cb, subqueryRoot));
 return subquery;
 }
}; The complete implementation of all the defined methods: select() public class SubQueryImpl<R> extends BaseQueryImpl<R, SubQueryImpl<R>> implements SubQuery<R, SubQueryImpl<R>> {
 ...

 @Override
 public SubqueryPredicate<R> select() {
 return (query, cb) -> {
 Subquery<R> subquery = query.subquery(type);
 Root<R> subqueryRoot = subquery.from(type);
 subquery
 .select(subqueryRoot)
 .where(buildPredicates(subquery, predicates, cb, subqueryRoot));
 return subquery;
 };
 }

 @Override
 public SubqueryPredicate select(SingularAttribute<R, P> attribute) {
 return (query, cb) -> {
 Subquery subquery = query.subquery(attribute.getJavaType());
 Root<R> subqueryRoot = subquery.from(type);
 subquery
 .select(subqueryRoot.get(attribute))
 .where(buildPredicates(subquery, predicates, cb, subqueryRoot));
 return subquery;
 };
 }

 @Override
 public <P1, P2> SubqueryPredicate<P2> select(SingularAttribute<R, P1> attribute1, SingularAttribute<P1, P2> attribute2) {
 return (query, cb) -> {
 Subquery<P2> subquery = query.subquery(attribute2.getJavaType());
 Root<R> subqueryRoot = subquery.from(type);
 subquery
 .select(subqueryRoot.get(attribute1).get(attribute2))
 .where(buildPredicates(subquery, predicates, cb, subqueryRoot));
 return subquery;
 };
 }

 @Override
 public <P1, P2, P3> SubqueryPredicate<P3> select(SingularAttribute<R, P1> attribute1, SingularAttribute<P1, P2> attribute2, SingularAttribute<P2, P3> attribute3) {
 return (query, cb) -> {
 Subquery<P3> subquery = query.subquery(attribute3.getJavaType());
 Root<R> subqueryRoot = subquery.from(type);
 subquery
 .select(subqueryRoot.get(attribute1).get(attribute2).get(attribute3))
 .where(buildPredicates(subquery, predicates, cb, subqueryRoot));
 return subquery;
 };
 }
} Now, we can compose a subquery using the and build an instance of the . But to apply the operator, we should define the filter in the interface. SubQueryImpl SubqueryPredicate IN in() BaseQuery 3. IN Operator In this section, we will define the absent filter in the interface. This method should accept the varargs argument as the selected value of : IN BaseQuery SubqueryPredicate<R> SubQuery public interface BaseQuery<R, Q extends BaseQuery<R, Q>> {
 ...

 Q in(SubqueryPredicate<R>... values);
} Next, we can specify additional methods accepting parameters to reach the nested relation which should be used in the operator. in() SingularAttribute IN In the following example, we use the filter to match the entity with the subquery, returning the entity: in() Address’s city Location City .in(Address_.city,
 subquery(Location.class)
 .isTrue(Location_.hasPriority)
 .select(Location_.city)
) Let’s define these additional methods accepting a different set of parent-child arguments, allowing us to use nested relations: in() SingularAttribute public interface BaseQuery<R, Q extends BaseQuery<R, Q>> {
 ...

 <V> Q in(SingularAttribute<R, V> attribute, SubqueryPredicate<V>... values);

 <P, V> Q in(SingularAttribute<R, P> attribute1, SingularAttribute<P, V> attribute2, SubqueryPredicate<V>... values);

 <P1, P2, V> Q in(SingularAttribute<R, P1> attribute1, SingularAttribute<P1, P2> attribute2, SingularAttribute<P2, V> attribute3, SubqueryPredicate<V>... values);
} Next, let’s implement defined methods in the . Each method should first map the varargs parameters to the instances using method and, after that, create a predicate with the operator for the path provided by parameters: in() BaseQueryImpl SubqueryPredicate javax.persistence.criteria.Subquery SubqueryPredicate#apply() IN SingularAttribute Predicate[] predicates = Arrays.stream(subqueryPredicates)
 .map(t -> t.apply(CommonAbstractCriteria, CriteriaBuilder))
 .map(subquery -> root.get(attribute).in(subquery))
 .toArray(Predicate[]::new); Now we can apply the to make a conjunction of the obtained predicates and finally, construct an instance of the : CriteriaBuilder#and() QueryPredicate new QueryPredicate<R>() {
 @Override
 public Predicate apply(CommonAbstractCriteria criteria, CriteriaBuilder cb, Path<R> root) {
 Predicate[] predicates = Arrays.stream(subqueryPredicates)
 .map(t -> t.apply(criteria, cb))
 .map(subquery -> root.get(attribute).in(subquery))
 .toArray(Predicate[]::new);
 return cb.and(predicates);
 }
}; There is the complete implementation of all methods: in() public abstract class BaseQueryImpl<R, Q extends BaseQueryImpl<R, Q>> implements BaseQuery<R, Q> {
 ...

 @SafeVarargs
 @Override
 public final Q in(SubqueryPredicate<R>... values) {
 predicates.add((criteria, cb, root) ->
 cb.and(
 Arrays.stream(values)
 .map(t -> t.apply(criteria, cb))
 .map(root::in)
 .toArray(Predicate[]::new)
 )
 );
 return self();
 }

 @SafeVarargs
 @Override
 public final <V> Q in(SingularAttribute<R, V> attribute, SubqueryPredicate<V>... values) {
 predicates.add((criteria, cb, root) ->
 cb.and(
 Arrays.stream(values)
 .map(t -> t.apply(criteria, cb))
 .map(subquery -> root.get(attribute).in(subquery))
 .toArray(Predicate[]::new)
 )
 );
 return self();
 }

 @SafeVarargs
 @Override
 public final <P, V> Q in(SingularAttribute<R, P> attribute1, SingularAttribute<P, V> attribute2, SubqueryPredicate<V>... values) {
 predicates.add((criteria, cb, root) ->
 cb.and(
 Arrays.stream(values)
 .map(t -> t.apply(criteria, cb))
 .map(subquery -> root.get(attribute1).get(attribute2).in(subquery))
 .toArray(Predicate[]::new)
 )
 );
 return self();
 }



 @SafeVarargs
 @Override
 public final <P1, P2, V> Q in(SingularAttribute<R, P1> attribute1, SingularAttribute<P1, P2> attribute2,
 SingularAttribute<P2, V> attribute3, SubqueryPredicate<V>... values) {
 predicates.add((criteria, cb, root) ->
 cb.and(
 Arrays.stream(values)
 .map(t -> t.apply(criteria, cb))
 .map(subquery -> root.get(attribute1).get(attribute2).get(attribute3).in(subquery))
 .toArray(Predicate[]::new)
 )
 );
 return self();
 }

} Lastly, to finish the implementation, we can provide static methods, allowing us to create nested predicates within the filters. in() IN and/or For example, the following query will retrieve the orders with a customer matching any of the provided subqueries: List<Order> ordersToSpainOrWithActiveMembership = criteriaApiHelper.select(Order.class)
 .or(Order_.customer,
 in(
 subquery(CustomerDetails.class)
 .isTrue(CustomerDetails_.isActiveMembership)
 .select(CustomerDetails_.customer)
 ),
 in(Customer_.address,
 subquery(AddressDetails.class)
 .equal(AddressDetails_.country, Country_.name, "Spain")
 .select(AddressDetails_.address)
 )
 )
 .findAll(); There is the implementation for all the static methods in the class: in() CriteriaApiHelper public class CriteriaApiHelper {
 ...
	
 @SafeVarargs
 public static <R> QueryPart<R> in(SubqueryPredicate<R>... values) {
 return new QueryPart<R>()
 .in(values);
 }

 @SafeVarargs
 public static <R, V> QueryPart<R> in(SingularAttribute<R, V> attribute, SubqueryPredicate<V>... values) {
 return new QueryPart<R>()
 .in(attribute, values);
 }

 @SafeVarargs
 public static <R, P, V> QueryPart<R> in(SingularAttribute<R, P> attribute1, SingularAttribute<P, V> attribute2,
 SubqueryPredicate<V>... values) {
 return new QueryPart<R>()
 .in(attribute1, attribute2, values);
 }

 @SafeVarargs
 public static <R, P1, P2, V> QueryPart<R> in(SingularAttribute<R, P1> attribute1, SingularAttribute<P1, P2> attribute2,
 SingularAttribute<P2, V> attribute3, SubqueryPredicate<V>... values) {
 return new QueryPart<R>()
 .in(attribute1, attribute2, attribute3, values);
 }
} 4. Wrapping Up In this part, we slightly improved extension for the Criteria API. Now we can perform the operator. IN

Improving Your Experience With CriteriaAPI Using Builder Pattern and JPA Static Metamodel - Part III

Improving your experience with Criteria API using Builder pattern and JPA Static Metamodel - Part I

The filter and pipeline patterns can be optimized with code reduction using lambda expression(shortcuts for anonymous method) as concrete filter condition. To demonstrate concept, the sample WPF UI application was created. Here is Source code Pipeline and filter pattern Traditionally filter pattern interface is implemented for every new filter. Instead of implementing interface for every filter condition, the generic lambda expression can be used as input to filters pipeline. As result, there will be less code. The following is class diagram: ConditionAggregator is pipeline class where it stores collection of Condition<T>. Filter<T> owns ConditionAggregator or Condition<T> to apply filter conditions on data collection. When Filter<T> apply function is called, ICondition<T> check method is executed.  ConditionAggregator<T> has event OnFilterChanged. It is triggered when the collection or condition value is changed at view model classes.  The next section will describes view model usage filter pattern. Using the code Usage in View Model MVVM framework explanation can be read in this . In MVVM  the one of responsibilities of the view model is to handle user interaction and data changes. In our case the filter condition value changes should be passed to business layer to apply filters on given data collection. The condition value changes in view model will trigger ConditionAggregator<T> OnFilterChanged event where filter apply method is subscribed. The following is class diagram of view model: link Employee entity class is created to contain employee information. The generic T type of filter design pattern will be replaced with Employee class. EmployeeList holds list of employee data and Filters to apply. The class constructor receives condition list and passes to filter list. EmployeeList(IEmployeesRepository repository, ConditionAggregator<employee> conditionAggregator)
 { .repository = repository; .filters = new ConcreteFilter<employee>(conditionAggregator);
 conditionAggregator.OnFilterChanged += .FilterList;
 _ = initAsync();
 } public this this this FilterList method is subscribed to OnFilterChanged event to apply filters on data when condition or value changed event occurs. void FilterList()
{ .Employees = .filters.Apply( .employeesFullList);
} private this this this EmployeesViewModel is connected to UI. In this sample application, the only one EmployeeTypeselected property filter is demonstrated but the many filters can be passed to ConditionAggregator. The following code snippet is constructor method where Filter condition is registered. public EmployeesViewModel(IEmployeesRepository repository)
 {
 this.repository = repository;
 Condition ;employee ; filterEmployee = new Condition ;employee ;((e) = ; e.employeeCode == this.EmployeeTypeSelected);
 this.conditionAggregator = new ConditionAggregator ;employee ;(new ;condition ;employee ; ; { filterEmployee });
 this.EmployeeList = new EmployeeList(repository, this.conditionAggregator); 
 } ;/condition ;employee ; ;/employee ; ;/employee ; ;/employee ; &lt &gt &lt &gt &gt &lt &gt List &lt &lt &gt &gt &lt &lt &gt &lt &gt &lt &gt &lt &gt The condition is given as lambda expression. It can be as many as necessary since ConditionAggregator constructor accepts the List of filter conditions. The primary goal of code reduction of creating specific filter condition class is achieved. Architecture of sample application WPF.Demo.DataFilter project is WPF UI view. It has one grid and one combobox to filter. WPF.Demo.DataFilter.ViewModels project handles data and filter changes and reloads data for UI update. WPF.Demo.DataFilter.Common project is full implementation of Filter and pipeline patterns. WPF.Demo.DataFilter.DAL loads simple json file as data store. This is main UI:

How To Use Filter Pattern With Generic Lambda Expression

Blockchain gaming models have gone through a phase of dramatic shifts in recent years. Play-to-earn remains a fundamental building block for most Web3 games, but developers are constantly working to implement more accessible and inclusive models that lower the barrier for a wider audience. The most recent iteration has been the Tap-to-earn model, gaining massive popularity this year for all the right reasons. Tap-to-earn games are simple. The core mechanic involves players repeatedly tapping or clicking on the screen to perform particular actions like mining resources, collecting items, or completing simple tasks. This simplicity means these games are for everyone, with no accessibility barrier, learning curve, or onboarding complexities. With each tap or completed task, players earn in-game rewards, which can be in the form of points, tokens, or other digital assets. Despite their surging popularity, these games are not without criticism, and there is lingering skepticism about their long-term value.  The simplicity of these games often serves as little more than a gimmick. What’s the purpose behind users constantly tapping their screens? What’s the engagement factor, and what value does it add? Without meaningful engagement or value creation, the current T2E model risks being unsustainable in the long run. TapSwap, one of the biggest tap-to-earn games in 2024, has recognized this issue and is actively working towards a sustainable solution. TapSwap's Play-Generate Value-Earn Model In response to these challenges, we are pioneering a new approach to T2E gaming that seeks to redefine how value is generated and distributed within these platforms. So, what is this "Play-Generate Value-Earn" philosophy? It pulls attention away from mindless tapping to interactions that can now yield real value, for the players as well as the platform. TapSwap will achieve this through the "Win-Win Monetization" business model. Players will win general rewards for their tapping actions and activities as per usual, but a certain portion of their earnings will be contributed back to the TapSwap platform. So, both the players and the project will be under a profit-sharing agreement, where both parties benefit from the game’s success. This will ultimately lead to a more sustainable and mutually beneficial ecosystem. This “Win-Win Monetization” model specifically addresses the challenges plaguing most tap-to-earn games, as they tend to lack perpetual value due to a single payout per customer. TapSwap incentivises long-term player payouts through the relative value of players' earnings on the platform. We motivate them to continue using the platform, inevitably increasing our player pool and jackpot values. This leads to a more engaged community and ensures a healthy financial structure for the platform. Partnerships and AI Integration: Enhancing the Earning Model To amplify the "Play-Generate Value-Earn" philosophy, we collaborate with top AI and data companies. When the next TapSwap iteration rolls around, users will engage with different elements of a game that exists as buildings inside a virtual space named Tappy Town. Among these interactions are real-world tasks like walking a particular distance or using the app to map out specific locations. Players complete these tasks to earn tokens, creating a direct dependency between in-game activities and their corresponding value. This improves the gaming experience and ensures that every tap means something. https://www.youtube.com/watch?v=JbTq-lHh2oU&embedable=true As players engage with different tasks, AI algorithms will monitor their behavior and preferences to generate personalized activities that align with individual interests or capabilities. With this level of personalization, it is guaranteed that users always get to play those things they like in the most suitable manner for them. In addition, applying AI to the platform's economy can balance supply and demand, avoiding inflationary pressures seen in other tap-to-earn games. TapSwap’s Commitment to True Value The long-term sustainability and expansion of tap-to-earn games come down to creating value. One of the most difficult issues for mass-market tap-to-earn titles is how they keep growing over time. Without a sense of purpose, these games will become redundant and fall out of the trends, much like several other Web3 gaming genres in recent years. That’s why our "Play-Generate Value-Earn" approach puts real value creation first. The project collaborates with third parties to incorporate real-world tasks into the game, ensuring that player activities are enjoyable and contribute to building a sustainable ecosystem. In addition, TapSwap is dedicated to providing transparent communication with their community. Players are informed and engaged with regular updates regarding new features, partnerships, and development. This helps build trust and nurtures an active community ready to support the platform's growth. Final Thoughts ‘Play-Generate Value-Earn’ is a promising direction for the future of tap-to-earn games. Adopting a profit-sharing mechanism helps us create a fairer distribution of rewards that encourages sustained user engagement. This approach addresses one of the key challenges similar gaming models face: maintaining long-term interest and preventing user attrition. For TapSwap, the combination of continuous updates, the introduction of new features, and strategic partnerships will help secure the project’s future and keep the game dynamic and engaging, avoiding the stagnation that has affected other play-to-earn models. This approach can potentially set new standards for sustainability in the tap-to-earn genre, offering insights that could benefit the broader GameFi sector. Blockchain gaming models have gone through a phase of dramatic shifts in recent years. Play-to-earn remains a fundamental building block for most Web3 games, but developers are constantly working to implement more accessible and inclusive models that lower the barrier for a wider audience. The most recent iteration has been the Tap-to-earn model, gaining massive popularity this year for all the right reasons. Tap-to-earn games are simple. The core mechanic involves players repeatedly tapping or clicking on the screen to perform particular actions like mining resources, collecting items, or completing simple tasks. This simplicity means these games are for everyone, with no accessibility barrier, learning curve, or onboarding complexities. With each tap or completed task, players earn in-game rewards, which can be in the form of points, tokens, or other digital assets. Despite their surging popularity, these games are not without criticism, and there is lingering skepticism about their long-term value.  The simplicity of these games often serves as little more than a gimmick. What’s the purpose behind users constantly tapping their screens? What’s the engagement factor, and what value does it add? Without meaningful engagement or value creation, the current T2E model risks being unsustainable in the long run. TapSwap , one of the biggest tap-to-earn games in 2024, has recognized this issue and is actively working towards a sustainable solution. TapSwap TapSwap TapSwap's Play-Generate Value-Earn Model In response to these challenges, we are pioneering a new approach to T2E gaming that seeks to redefine how value is generated and distributed within these platforms. So, what is this "Play-Generate Value-Earn" philosophy? It pulls attention away from mindless tapping to interactions that can now yield real value, for the players as well as the platform. TapSwap will achieve this through the "Win-Win Monetization" business model. Players will win general rewards for their tapping actions and activities as per usual, but a certain portion of their earnings will be contributed back to the TapSwap platform. So, both the players and the project will be under a profit-sharing agreement, where both parties benefit from the game’s success. This will ultimately lead to a more sustainable and mutually beneficial ecosystem. This “Win-Win Monetization” model specifically addresses the challenges plaguing most tap-to-earn games, as they tend to lack perpetual value due to a single payout per customer. TapSwap incentivises long-term player payouts through the relative value of players' earnings on the platform. We motivate them to continue using the platform, inevitably increasing our player pool and jackpot values. This leads to a more engaged community and ensures a healthy financial structure for the platform. TapSwap TapSwap Partnerships and AI Integration: Enhancing the Earning Model To amplify the "Play-Generate Value-Earn" philosophy, we collaborate with top AI and data companies. When the next TapSwap iteration rolls around, users will engage with different elements of a game that exists as buildings inside a virtual space named Tappy Town. Among these interactions are real-world tasks like walking a particular distance or using the app to map out specific locations. Players complete these tasks to earn tokens, creating a direct dependency between in-game activities and their corresponding value. This improves the gaming experience and ensures that every tap means something. https://www.youtube.com/watch?v=JbTq-lHh2oU&embedable=true https://www.youtube.com/watch?v=JbTq-lHh2oU&embedable=true As players engage with different tasks, AI algorithms will monitor their behavior and preferences to generate personalized activities that align with individual interests or capabilities. With this level of personalization, it is guaranteed that users always get to play those things they like in the most suitable manner for them. In addition, applying AI to the platform's economy can balance supply and demand, avoiding inflationary pressures seen in other tap-to-earn games. TapSwap’s Commitment to True Value The long-term sustainability and expansion of tap-to-earn games come down to creating value. One of the most difficult issues for mass-market tap-to-earn titles is how they keep growing over time. Without a sense of purpose, these games will become redundant and fall out of the trends, much like several other Web3 gaming genres in recent years. That’s why our "Play-Generate Value-Earn" approach puts real value creation first. The project collaborates with third parties to incorporate real-world tasks into the game, ensuring that player activities are enjoyable and contribute to building a sustainable ecosystem. In addition, TapSwap is dedicated to providing transparent communication with their community. Players are informed and engaged with regular updates regarding new features, partnerships, and development. This helps build trust and nurtures an active community ready to support the platform's growth. Final Thoughts ‘Play-Generate Value-Earn’ is a promising direction for the future of tap-to-earn games. Adopting a profit-sharing mechanism helps us create a fairer distribution of rewards that encourages sustained user engagement. This approach addresses one of the key challenges similar gaming models face: maintaining long-term interest and preventing user attrition. For TapSwap, the combination of continuous updates, the introduction of new features, and strategic partnerships will help secure the project’s future and keep the game dynamic and engaging, avoiding the stagnation that has affected other play-to-earn models. This approach can potentially set new standards for sustainability in the tap-to-earn genre, offering insights that could benefit the broader GameFi sector.

From Clicks to Value: TapSwap's Sustainable Approach to Tap-to-Earn

Od klikova do vrijednosti: održivi pristup TapSwap-a za zaradu

De los clics al valor: el enfoque sostenible de TapSwap para ganar dinero con solo tocar

Des clics à la valeur : l'approche durable de TapSwap pour gagner de l'argent

Սեղմումներից մինչև արժեք. TapSwap-ի կայուն մոտեցում՝ Tap-to-Earn

クリックから価値へ: TapSwap の Tap-to-Earn への持続可能なアプローチ

클릭에서 가치로: TapSwap의 지속 가능한 Tap-to-Earn 접근 방식

Daripada Klik kepada Nilai: Pendekatan Mampan TapSwap untuk Ketik untuk Mendapat

De la clicuri la valoare: abordarea durabilă a TapSwap de a atinge pentru a câștiga

От кликов к ценности: устойчивый подход TapSwap к получению дохода при нажатии

Од кликова до вредности: одрживи приступ ТапСвап-а да зарадите

Çykyşlardan gymmata çenli: TapSwap-yň Tap-to-gazanç üçin durnukly çemeleşmesi

Mula sa Mga Pag-click hanggang sa Halaga: Ang Sustainable Approach ng TapSwap para Mag-tap-to-Earn

Applying Transitive Closure to Sort Products Into Categories, Considering Nesting and Overlaps

In one of the many collaborative sessions with various flavors of LLMs - in this case, Claude - I arrived at this list of heuristics. It seems like once you reach some early-mid point of your career in tech, you create a portfolio page (still to be done), and you put a post with your heuristics on it (now, done). They lived in my personal notes for a few weeks, never to be published, but I caught myself coming back to them almost daily at work. All of them meta-game the approach to working with emerging tech; it seems they deserve to be here. Just Another Interview Question Any professional conundrum can be framed as a case study interview question, and those - being hypothetical and emotionless - are much easier to handle than real-life scenarios. Apply to get yourself out of a conundrum with cold logic, experience, and without an emotional load clouding your judgment. Friction Fulcrum Friction in a process increases overall quality. Too little leads to carelessness, too much is gridlock. Apply for a little extra motivation when dealing with pushback from stakeholders, an unreceptive market, or other ✨offputting✨ circumstances. Cognitive Compost Some ideas are scraps and peels. They need to decompose in the brain’s background processes to resurface as something innovative and useful. Apply when frustrated about wasted work that ended up going nowhere. Skill Scaffolding Learning is modular, especially in tech. Any new skills, even seemingly specific, are a modular block to quickly adapt to the next knowledge gap. Apply when unmotivated to learn a new skill that seems too specific or niche, or when demotivated by having to pivot to a new field. Innovation Inertia The bigger the past successes (or market share) of the organization, the bigger the resistance to change. A flavor of The Innovator’s Dilemma. Apply to protect sanity when building experimental projects in large organizations. Collaborative Crystallization Loose ideas align and form a cohesive strategy in a group setting. Apply when debating whether the half-baked idea is worth bringing up to the team. Expertise Erosion In the long run, overfocusing on one field of expertise - especially coupled with staying out of the loop on emerging tech and changing markets - makes you relatively obsolete. Apply when rolling your eyes at yet another AI headline. Decisional Doppler Effect The closer you are to decisions, the higher their urgency and importance seem to be. They’re usually not that important, or that urgent, and benefit from taking a breath and looking at the broader context. Apply when getting stressed out about work. The next three posts, currently sitting defeated in my half-baked-and-unfinished queue: The intersection of the California AI bill, and the impact of regulation on past technological breakthroughs
Innovating from first principles and this batch of AI products
Calling The Peak of Inflated Expectations for AI If you reply or comment with your pick, I will (most likely) actually finish it. In one of the many collaborative sessions with various flavors of LLMs - in this case, Claude - I arrived at this list of heuristics. It seems like once you reach some early-mid point of your career in tech, you create a portfolio page (still to be done), and you put a post with your heuristics on it (now, done). collaborative They lived in my personal notes for a few weeks, never to be published, but I caught myself coming back to them almost daily at work. All of them meta-game the approach to working with emerging tech; it seems they deserve to be here. Just Another Interview Question Any professional conundrum can be framed as a case study interview question, and those - being hypothetical and emotionless - are much easier to handle than real-life scenarios. Apply to get yourself out of a conundrum with cold logic, experience, and without an emotional load clouding your judgment. Friction Fulcrum Friction in a process increases overall quality. Too little leads to carelessness, too much is gridlock. Apply for a little extra motivation when dealing with pushback from stakeholders, an unreceptive market, or other ✨offputting✨ circumstances. Cognitive Compost Some ideas are scraps and peels. They need to decompose in the brain’s background processes to resurface as something innovative and useful. Apply when frustrated about wasted work that ended up going nowhere. Skill Scaffolding Learning is modular, especially in tech. Any new skills, even seemingly specific, are a modular block to quickly adapt to the next knowledge gap. Apply when unmotivated to learn a new skill that seems too specific or niche, or when demotivated by having to pivot to a new field. Innovation Inertia The bigger the past successes (or market share) of the organization, the bigger the resistance to change. A flavor of The Innovator’s Dilemma . Apply to protect sanity when building experimental projects in large organizations. The Innovator’s Dilemma Collaborative Crystallization Loose ideas align and form a cohesive strategy in a group setting. Apply when debating whether the half-baked idea is worth bringing up to the team. Expertise Erosion In the long run, overfocusing on one field of expertise - especially coupled with staying out of the loop on emerging tech and changing markets - makes you relatively obsolete. Apply when rolling your eyes at yet another AI headline. Decisional Doppler Effect The closer you are to decisions, the higher their urgency and importance seem to be. They’re usually not that important, or that urgent, and benefit from taking a breath and looking at the broader context. Apply when getting stressed out about work. The next three posts, currently sitting defeated in my half-baked-and-unfinished queue: The intersection of the California AI bill, and the impact of regulation on past technological breakthroughs Innovating from first principles and this batch of AI products Calling The Peak of Inflated Expectations for AI The intersection of the California AI bill, and the impact of regulation on past technological breakthroughs Innovating from first principles and this batch of AI products Calling The Peak of Inflated Expectations for AI If you reply or comment with your pick, I will (most likely) actually finish it.

Stuck? Here Are Some Heuristics to Apply Liberally

User Experience design methodologies are known for their effectiveness in improving the usability, accessibility, and satisfaction of digital products and services. However, their principles can also be applied to solving everyday tasks that we face in various aspects of our lives and can be applied to relocation. They include understanding user needs, prioritizing simplicity and effectiveness, and fostering innovation through ideation and prototyping. Moving to another country can be a challenging process that can be overcome and made easier by learning about people and their experiences, using your previous positive experiences in a new environment, and UX design principles to better adapt. Moving doesn’t have to be a cold and bureaucratic process; it can be an unforgettable adventure full of exciting discoveries and opportunities. The most effective strategy is to be able to adapt your style to the current situation, which means being positive, flexible, and resilient. By applying UX design strategies to the moving process, you can improve your transition experience and turn potential obstacles into manageable steps, making the process smoother and more enjoyable. 1. User Research is Key Moving to a new country and integrating into a different cultural environment can be daunting. Be prepared to adapt your styles and strategies to fit in and succeed. Just as UX design begins with understanding the user, a successful move begins with comprehensive research. Moving to a new country means immersing yourself in a different cultural and social environment. Use your previous experience and past successful strategies in new contexts to ensure a smoother transition. Start by understanding local norms, cultural expectations, and workplace behavior in your new environment. Research the neighborhood, transportation, and cultural nuances thoroughly to ensure a smooth transition. Even finding familiar products in the supermarket can be challenging, so take the time to learn about your new environment. Use the Discovery phase to focus on field research and observation, seeking insights, understanding key personas, and learning how people like you are coping with the same issues you are currently facing. There are many local communities, Facebook groups, and Telegram chats that can be helpful in this regard. 2. Onboarding Rituals Onboarding is an umbrella term for a wide range of formal and informal activities and processes that require meaningful management. Incorporating onboarding rituals into your life is like giving yourself a cheat code for the city—making yourself feel like a new home has been on your radar for years. It’s a great way to turn your move into a journey of joy and connection. Create a list of things you want to see and explore. A list is a way to organize your routine, and exploring iconic landmarks, trying out a variety of cuisines, and participating in local traditions can become rituals that make you feel more connected to the city. This can create a sense of belonging and help you connect with your new environment. “A sense of belonging – the subjective feeling of deep connection with social groups, physical places, and individual and collective experiences – is a fundamental human need that predicts numerous mental, physical, social, economic, and behavioural outcomes”. K.-A. Allen, M. L. Kern, C. S. Rozek, D. M. McInerney, and G. M. Slavich. 3. Wireframe Your Routine A wireframe is a low-fidelity visualization of your future design that can help you find the right balance between accuracy and speed. You don’t have to go into too much detail, but if you want to create a solid representation of your life in the new place without missing any important details, consider the wireframe as the basis for your planning. A daily routine that includes work, exercise, rest, and exploration will help create it. This structured approach will make the adaptation process easier. In addition to helping you focus and lowering tension and anxiety, visualization can also be a tactic for boosting resilience and positivity. Wireframes are quick to create and don't require a lot of detail, but you may not be familiar with the details because you've just moved into your new place. Over time, you can refine the final picture. “Creative visualisation not only helps visualise a favourable resolution to a stressful situation, but can also serve as a “mental rehearsal” for success in any activity”. E. Makarova, E. Degtyareva, and O. Kholina. 4. Social Circle UX Testing Creating a social circle in a new place often involves building it from scratch, as well as experimenting multiple times with different meet-ups and events to find like-minded people. Just like with UX design, UX testing your social circles helps you find the right mix of connections that add value to the relocation experience. Local communities, volunteer sessions, apps like Eventbrite, Locals, Meetup, LinkedIn, Bumble for friends, and many more can help you practice and make new friends. Find the right approach for you or try something new, who knows what will work best in a new place. Don’t be afraid to start communicating, even if it’s not clear how or what to do, because the more practice you have, the better you will be at making new connections. 5. Iterate Based on Feedback After testing your new social circle, you can write down and analyze your findings, as well as seek advice from local residents, get feedback on various aspects of city life, and adjust your approach accordingly. An iterative approach helps in refining the onboarding process by focusing on improvements to meet your needs and expand the accessibility of the new environment, thus illustrating a continuous movement towards a more you-centric approach. Including and integrating feedback from a variety of people provides a more holistic view of what's happening to you in the new environment, and different perspectives lead to improvement and enrichment. At the heart of UX design is optimization: an iteratively improved solution to a general problem. Here is a recipe for solving the problems of moving to a new place using an iterative approach: if you fail, try again, just like in the iterative approach in UX design. You can improve your techniques. No one is perfect. Try, get feedback, improve, test again, execute and win! The main thing is to try and never stop! Conclusion Hope these ideas inspire you to embrace a design mindset, ease your transition into a new environment, and turn everyday challenges into opportunities. Ultimately, developing a UX design mindset requires dedication but promises invaluable benefits in enhancing the quality of everyday experiences. User Experience design methodologies are known for their effectiveness in improving the usability, accessibility, and satisfaction of digital products and services. However, their principles can also be applied to solving everyday tasks that we face in various aspects of our lives and can be applied to relocation. They include understanding user needs, prioritizing simplicity and effectiveness, and fostering innovation through ideation and prototyping. Moving to another country can be a challenging process that can be overcome and made easier by learning about people and their experiences, using your previous positive experiences in a new environment, and UX design principles to better adapt. Moving doesn’t have to be a cold and bureaucratic process; it can be an unforgettable adventure full of exciting discoveries and opportunities. The most effective strategy is to be able to adapt your style to the current situation, which means being positive, flexible, and resilient. By applying UX design strategies to the moving process, you can improve your transition experience and turn potential obstacles into manageable steps, making the process smoother and more enjoyable. 1. User Research is Key 1. User Research is Key Moving to a new country and integrating into a different cultural environment can be daunting. Be prepared to adapt your styles and strategies to fit in and succeed. Just as UX design begins with understanding the user, a successful move begins with comprehensive research. Moving to a new country means immersing yourself in a different cultural and social environment. Use your previous experience and past successful strategies in new contexts to ensure a smoother transition. Start by understanding local norms, cultural expectations, and workplace behavior in your new environment. Research the neighborhood, transportation, and cultural nuances thoroughly to ensure a smooth transition. Even finding familiar products in the supermarket can be challenging, so take the time to learn about your new environment. Use the Discovery phase to focus on field research and observation, seeking insights, understanding key personas, and learning how people like you are coping with the same issues you are currently facing. There are many local communities, Facebook groups, and Telegram chats that can be helpful in this regard. 2. Onboarding Rituals Onboarding Rituals Onboarding is an umbrella term for a wide range of formal and informal activities and processes that require meaningful management. Incorporating onboarding rituals into your life is like giving yourself a cheat code for the city—making yourself feel like a new home has been on your radar for years. It’s a great way to turn your move into a journey of joy and connection. Create a list of things you want to see and explore. A list is a way to organize your routine, and exploring iconic landmarks, trying out a variety of cuisines, and participating in local traditions can become rituals that make you feel more connected to the city. This can create a sense of belonging and help you connect with your new environment. “A sense of belonging – the subjective feeling of deep connection with social groups, physical places, and individual and collective experiences – is a fundamental human need that predicts numerous mental, physical, social, economic, and behavioural outcomes”. K.-A. Allen, M. L. Kern, C. S. Rozek, D. M. McInerney, and G. M. Slavich. “A sense of belonging – the subjective feeling of deep connection with social groups, physical places, and individual and collective experiences – is a fundamental human need that predicts numerous mental, physical, social, economic, and behavioural outcomes”. K.-A. Allen, M. L. Kern, C. S. Rozek, D. M. McInerney, and G. M. Slavich. “A sense of belonging – the subjective feeling of deep connection with social groups, physical places, and individual and collective experiences – is a fundamental human need that predicts numerous mental, physical, social, economic, and behavioural outcomes”. 3. Wireframe Your Routine 3. Wireframe Your Routine A wireframe is a low-fidelity visualization of your future design that can help you find the right balance between accuracy and speed. You don’t have to go into too much detail, but if you want to create a solid representation of your life in the new place without missing any important details, consider the wireframe as the basis for your planning. A daily routine that includes work, exercise, rest, and exploration will help create it. This structured approach will make the adaptation process easier. In addition to helping you focus and lowering tension and anxiety, visualization can also be a tactic for boosting resilience and positivity. Wireframes are quick to create and don't require a lot of detail, but you may not be familiar with the details because you've just moved into your new place. Over time, you can refine the final picture. “Creative visualisation not only helps visualise a favourable resolution to a stressful situation, but can also serve as a “mental rehearsal” for success in any activity”. E. Makarova, E. Degtyareva, and O. Kholina. “Creative visualisation not only helps visualise a favourable resolution to a stressful situation, but can also serve as a “mental rehearsal” for success in any activity”. E. Makarova, E. Degtyareva, and O. Kholina. “Creative visualisation not only helps visualise a favourable resolution to a stressful situation, but can also serve as a “mental rehearsal” for success in any activity”. 4. Social Circle UX Testing 4. Social Circle UX Testing Creating a social circle in a new place often involves building it from scratch, as well as experimenting multiple times with different meet-ups and events to find like-minded people. Just like with UX design, UX testing your social circles helps you find the right mix of connections that add value to the relocation experience. Local communities, volunteer sessions, apps like Eventbrite, Locals, Meetup, LinkedIn, Bumble for friends, and many more can help you practice and make new friends. Find the right approach for you or try something new, who knows what will work best in a new place. Don’t be afraid to start communicating, even if it’s not clear how or what to do, because the more practice you have, the better you will be at making new connections. 5. Iterate Based on Feedback 5. Iterate Based on Feedback After testing your new social circle, you can write down and analyze your findings, as well as seek advice from local residents, get feedback on various aspects of city life, and adjust your approach accordingly. An iterative approach helps in refining the onboarding process by focusing on improvements to meet your needs and expand the accessibility of the new environment, thus illustrating a continuous movement towards a more you-centric approach. Including and integrating feedback from a variety of people provides a more holistic view of what's happening to you in the new environment, and different perspectives lead to improvement and enrichment. At the heart of UX design is optimization: an iteratively improved solution to a general problem. Here is a recipe for solving the problems of moving to a new place using an iterative approach: if you fail, try again, just like in the iterative approach in UX design. You can improve your techniques. No one is perfect. Try, get feedback, improve, test again, execute and win! The main thing is to try and never stop! Conclusion Hope these ideas inspire you to embrace a design mindset, ease your transition into a new environment, and turn everyday challenges into opportunities. Ultimately, developing a UX design mindset requires dedication but promises invaluable benefits in enhancing the quality of everyday experiences.

Beyond Digital: Applying UX Principles to Relocation

After a decade of software engineering work (professional and personal), particularly in front-end development, I’ve crafted something I’m proud of. In this article, I’ll walk you through my ideal tech stack and the intricate decisions that shaped MeetMomentum. Join me as we explore the nuts and bolts of building a tool designed to revolutionize how we manage time across global time zones. Project Overview In today’s connected world, tools to track global timezones aren’t just a necessity; they’re a lifeline for professionals and travellers alike. Unfortunately, most calendar solutions do not offer effective multi-time zone support when scheduling and I personally faced many struggles because of this. That’s how I started to come up with the MeetMomentum vision. I wanted to build something that truly accounts for infinite time zones, visually and intuitively. I also wanted to make sure it integrates with my existing calendar, so I don't have to look at multiple screens just to book a single meeting. Design The design was one of the biggest challenges. There is a good reason why most applications don't support more than two time zones. It is not possible to fit all that information, in a digestible manner. At least not with the existing approach. The existing approach is having all five days aligned and invitees’ agendas overlapping. Instead, we flipped the calendar view on it’s side, presenting each invitee's schedule on their own horizontal line, offset by their unique time zone. To navigate the calender users can simply swipe or scroll horizontally, and by maintaining the offset, we ensure perfect time zone alignment, in a very clean manner. This is the core of our innovation, however, it came with a surprising set of technical challenges! Have a play on the final outcome here: https://www.meetmomentum.tech/ Technical Stack Before diving any deeper, let's start by painting the landscape. Embarking on any software project requires a solid foundation, and the technical stack is where it all begins. In the development of MeetMomentum, choosing the right technologies was crucial to ensure flexibility, efficiency, and scalability. Programming Languages Used: TypeScript/JavaScript


CSS


Markdown/MDX for the blog Frameworks and Libraries: We used pure tailwind for styling, with no extra component libraries, outside a few specific cases where we have utilized Headless UI. We used Framer Motion for more custom animations. Drizzle as a lightweight ORM for composing typesafe queries and managing schema migrations. TRPC for simple server-client connectivity. Zod for validation of data inputs. react-hook-form for user input with its great integration with zod. Tools and Development Environment: Currently, we’re just using npm but might lean into pnpm. We use prettier for formatting. Eslint with various plugins for React, typescript, etc. in order to catch simple issues. Nix is used to provide dependencies outside of node_modules. Stripe dev cli. Architecture Overview: The architecture leans serverless. Being on Vercel, we leverage functions for our serverside compute. As we use supabase, we can also utilize PostgREST and Row Level Security (RLS) to directly and securely access data in the database. And being React on NextJS we can lean into SSG and client-side processing. Database Management: As mentioned above the database is Postgres on Supabase with RLS and PostgREST being key plugins. Server Infrastructure: Hosting on Vercel. Design Patterns: Design patterns such as MVC don’t really map onto React very well. The general approach is to keep the state as close to where it’s used so updates are only triggered for relevant areas of the page. Optimizations can be made in cases where updates are triggered but inputs have not meaningfully changed. State that is important across the application is handled via Zustand. In some cases, components are split into the part that handles and provides state, and the part that is visual with elements and styles. This can help to build out the component’s style and debug without needing to replicate the exact state in a more real-world scenario. However, sometimes it’s easier to have a combined component just to get something finished. Continuous Integration/Continuous Deployment (CI/CD): Vercel integration with GH runs ‘build’ and we run most of our linting and tests as part of that build. With a focus on SSG and client-side processing server-side compute is reduced. The vast majority of server-side compute is tied to accounts that can be managed carefully, and Vercel has capabilities to defend against abuse such as a DDoS attack. So, in general, the platform should scale very well without much intervention. There is room to improve some actions so we can leverage caching more or consolidate some requests but these are not of high concern until we reach much larger scales and can be worked on in the background. Major Challenges As mentioned before, one of the biggest challenges was building the horizontal scroll for the scheduling offsets. This would technically be called an ‘infinite horizontal scroll sync,’ and it seems like we were the first use case for it! The reason why it was so challenging was managing the browsers’ performance while triggering many browser events due to scrolling and lining up timezones accounting for their offsets. Keep in mind that each horizontal line had to be kept independent, as the user could at any point change the order with our ‘drag and drop’ features. And to make things harder for ourselves, we also had multiple time pickers that worked by aligning the exact position of the scroller. We tried multiple approaches, like having individual hour elements, and had to restart on at least four different occasions. But the result was worth it! Another major challenge was transitioning from the public scheduler to a personalized one, that integrates with your agenda. This time, the problem lies in trying to fit the agenda-related information into a small horizontal view. To get to our fleshed-out product, we had to undertake a lot of iteration, trial and error, and of course, user feedback! We also faced multiple technical challenges, such as integrating with the Google Calendar APIs, getting permission to handle user’s data, and so on. Outcomes User feedback for MeetMomentum.tech has been very positive. Users enjoy the convenience and creativity aspects, but we are still very early in our journey. Stay tuned as we evolve, enhancing MeetMomentum.tech to better serve you and the global community; one update at a time. After a decade of software engineering work (professional and personal), particularly in front-end development, I’ve crafted something I’m proud of. In this article, I’ll walk you through my ideal tech stack and the intricate decisions that shaped MeetMomentum. Join me as we explore the nuts and bolts of building a tool designed to revolutionize how we manage time across global time zones. Project Overview In today’s connected world, tools to track global timezones aren’t just a necessity; they’re a lifeline for professionals and travellers alike. Unfortunately, most calendar solutions do not offer effective multi-time zone support when scheduling and I personally faced many struggles because of this. That’s how I started to come up with the MeetMomentum vision. I wanted to build something that truly accounts for infinite time zones, visually and intuitively. I also wanted to make sure it integrates with my existing calendar, so I don't have to look at multiple screens just to book a single meeting. Design The design was one of the biggest challenges. There is a good reason why most applications don't support more than two time zones. It is not possible to fit all that information, in a digestible manner. At least not with the existing approach. The existing approach is having all five days aligned and invitees’ agendas overlapping. Instead, we flipped the calendar view on it’s side, presenting each invitee's schedule on their own horizontal line, offset by their unique time zone. To navigate the calender users can simply swipe or scroll horizontally, and by maintaining the offset, we ensure perfect time zone alignment, in a very clean manner. This is the core of our innovation, however, it came with a surprising set of technical challenges! Have a play on the final outcome here: https://www.meetmomentum.tech/ https://www.meetmomentum.tech/ Technical Stack Before diving any deeper, let's start by painting the landscape. Embarking on any software project requires a solid foundation, and the technical stack is where it all begins. In the development of MeetMomentum, choosing the right technologies was crucial to ensure flexibility, efficiency, and scalability. Programming Languages Used: Programming Languages Used: TypeScript/JavaScript CSS Markdown/MDX for the blog TypeScript/JavaScript TypeScript/JavaScript CSS CSS Markdown/MDX for the blog Markdown/MDX for the blog Frameworks and Libraries: Frameworks and Libraries: We used pure tailwind for styling, with no extra component libraries, outside a few specific cases where we have utilized Headless UI. We used pure tailwind for styling, with no extra component libraries, outside a few specific cases where we have utilized Headless UI. We used Framer Motion for more custom animations. We used Framer Motion for more custom animations. Drizzle as a lightweight ORM for composing typesafe queries and managing schema migrations. Drizzle as a lightweight ORM for composing typesafe queries and managing schema migrations. TRPC for simple server-client connectivity. TRPC for simple server-client connectivity. Zod for validation of data inputs. Zod for validation of data inputs. react-hook-form for user input with its great integration with zod. react-hook-form for user input with its great integration with zod. react-hook-form for user input with its great integration with zod. Tools and Development Environment: Tools and Development Environment: Currently, we’re just using npm but might lean into pnpm. Currently, we’re just using npm but might lean into pnpm. We use prettier for formatting. We use prettier for formatting. Eslint with various plugins for React, typescript, etc. in order to catch simple issues. Eslint with various plugins for React, typescript, etc. in order to catch simple issues. Nix is used to provide dependencies outside of node_modules. Nix is used to provide dependencies outside of node_modules. Stripe dev cli. Stripe dev cli. Architecture Overview: Architecture Overview: The architecture leans serverless. Being on Vercel, we leverage functions for our serverside compute. As we use supabase, we can also utilize PostgREST and Row Level Security (RLS) to directly and securely access data in the database. And being React on NextJS we can lean into SSG and client-side processing. Database Management: Database Management: As mentioned above the database is Postgres on Supabase with RLS and PostgREST being key plugins. Server Infrastructure: Server Infrastructure: Hosting on Vercel. Design Patterns: Design Patterns: Design patterns such as MVC don’t really map onto React very well. The general approach is to keep the state as close to where it’s used so updates are only triggered for relevant areas of the page. Optimizations can be made in cases where updates are triggered but inputs have not meaningfully changed. State that is important across the application is handled via Zustand. In some cases, components are split into the part that handles and provides state, and the part that is visual with elements and styles. This can help to build out the component’s style and debug without needing to replicate the exact state in a more real-world scenario. However, sometimes it’s easier to have a combined component just to get something finished. Continuous Integration/Continuous Deployment (CI/CD): Continuous Integration/Continuous Deployment (CI/CD): Vercel integration with GH runs ‘build’ and we run most of our linting and tests as part of that build. With a focus on SSG and client-side processing server-side compute is reduced. The vast majority of server-side compute is tied to accounts that can be managed carefully, and Vercel has capabilities to defend against abuse such as a DDoS attack. So, in general, the platform should scale very well without much intervention. There is room to improve some actions so we can leverage caching more or consolidate some requests but these are not of high concern until we reach much larger scales and can be worked on in the background. Major Challenges As mentioned before, one of the biggest challenges was building the horizontal scroll for the scheduling offsets. This would technically be called an ‘infinite horizontal scroll sync,’ and it seems like we were the first use case for it! The reason why it was so challenging was managing the browsers’ performance while triggering many browser events due to scrolling and lining up timezones accounting for their offsets. Keep in mind that each horizontal line had to be kept independent, as the user could at any point change the order with our ‘drag and drop’ features. And to make things harder for ourselves, we also had multiple time pickers that worked by aligning the exact position of the scroller. We tried multiple approaches, like having individual hour elements, and had to restart on at least four different occasions. But the result was worth it! Another major challenge was transitioning from the public scheduler to a personalized one, that integrates with your agenda. This time, the problem lies in trying to fit the agenda-related information into a small horizontal view. To get to our fleshed-out product, we had to undertake a lot of iteration, trial and error, and of course, user feedback! We also faced multiple technical challenges, such as integrating with the Google Calendar APIs, getting permission to handle user’s data, and so on. Outcomes User feedback for MeetMomentum.tech has been very positive. Users enjoy the convenience and creativity aspects, but we are still very early in our journey. Stay tuned as we evolve, enhancing MeetMomentum.tech to better serve you and the global community; one update at a time.

How I Built MeetMomentum: Applying 10 Years of React Experience

You can jump to any part of the United States International Cyberspace & Digital Policy Strategy here. This part is 30 of 38. Line of Effort 5: Affirm Application of Mutual Defense Treaties with Certain Allies to the Cyber Domain In line with the long-standing U.S. recognition that existing international law applies in cyberspace, obligations under treaties and other international agreements may apply in cyberspace. Over the past several years, the United States and certain allies have made public statements affirming the application in cyberspace of obligations in their respective mutual defense treaties, including the 1951 Security Treaty between Australia, New Zealand and the United States (ANZUS) (2011); the North Atlantic Treaty (2014); the Treaty of Mutual Cooperation and Security between the United States and Japan (2019); and the Mutual Defense Treaty between the United States and the Republic of Korea (2023). The Departments of State and Defense will continue to work together with allies to engage in pre-contingency planning and to raise awareness further with alliance partners that existing mutual defense treaties may apply in cyberspace and that cyberattacks rising to the level of an armed attack may trigger mutual defense obligations under such treaties. Continue Reading Here. This post was originally published on May 6, 2024, by the U.S Department of State You can jump to any part of the United States International Cyberspace & Digital Policy Strategy here. This part is 30 of 38. You can jump to any part of the United States International Cyberspace & Digital Policy Strategy here . This part is 30 of 38. here here Line of Effort 5: Affirm Application of Mutual Defense Treaties with Certain Allies to the Cyber Domain In line with the long-standing U.S. recognition that existing international law applies in cyberspace, obligations under treaties and other international agreements may apply in cyberspace. Over the past several years, the United States and certain allies have made public statements affirming the application in cyberspace of obligations in their respective mutual defense treaties, including the 1951 Security Treaty between Australia, New Zealand and the United States (ANZUS) (2011); the North Atlantic Treaty (2014); the Treaty of Mutual Cooperation and Security between the United States and Japan (2019); and the Mutual Defense Treaty between the United States and the Republic of Korea (2023). The Departments of State and Defense will continue to work together with allies to engage in pre-contingency planning and to raise awareness further with alliance partners that existing mutual defense treaties may apply in cyberspace and that cyberattacks rising to the level of an armed attack may trigger mutual defense obligations under such treaties. Continue Reading Here. Continue Reading Here . Here This post was originally published on May 6, 2024, by the U.S Department of State This post was originally published on May 6, 2024, by the U.S Department of State by the U.S Department of State by the U.S Department of State

Cybersecurity Alliances: Applying Mutual Defense Treaties to Combat Cyber Threats

Memoization is awesome. Let's abuse it. TL;DR: Don't apply premature optimization too early Problems Readability
Code Complexity
Premature Optimization
Obscured Logic Solutions Apply memoization in actual real business situations, and measure its impact through empirical benchmarks. Context Memoization can help you improve the performance of recursive functions involving redundant computations but compromise code readability and maintainability. It would help if you only used it with strong factual evidence on real business case scenarios. Sample Code Wrong memo = {}
def factorial_with_memo(n):
    if n in memo:
        return memo[n]
    if n == 0:
        return 1
    result = n * factorial_with_memo(n-1)
    memo[n] = result
    return result
  
  # This function optimizes the computation of factorials
  # by storing previously computed values,
  # reducing redundant calculations 
  # and improving performance for large inputs. Right def factorial(n):
    if n == 0:
        return 1
    return n * factorial(n-1) Detection [x]Semi-Automatic You can search for all places where you are using this technique and validate if they are worth it. Exceptions Real performance problems with strong factual evidence Tags Premature Optimization Level [x]Intermediate AI Generation Unless you explicitly ask the IAs to use this technique, they will suggest cleaner solutions. AI Detection ChatGPT, Gemini, and Claude.ai detect some problems with this technique but do not mention readability as a concern. Conclusion It would be best if you kept a balance between performance optimization and code clarity. You can consider alternatives such as iterative approaches or algorithmic optimizations since memoization significantly compromises code readability. Relations Code Smell 06 - Too Clever Programmer Code Smell 20 - Premature Optimization More Info Wikipedia Disclaimer Code Smells are my opinion. Credits Photo by Steffen Lemmerzahl on Unsplash A cache with a bad policy is another name for a memory leak. Rico Mariani Software Engineering Great Quotes This article is part of the CodeSmell Series. How to Find the Stinky Parts of your Code Memoization is awesome. Let's abuse it. Memoization is awesome. Let's abuse it. TL;DR: Don't apply premature optimization too early TL;DR: Don't apply premature optimization too early premature optimization Problems Readability Code Complexity Premature Optimization Obscured Logic Readability Code Complexity Premature Optimization Obscured Logic Solutions Apply memoization in actual real business situations, and measure its impact through empirical benchmarks. Apply memoization in actual real business situations, and measure its impact through empirical benchmarks. memoization Context Memoization can help you improve the performance of recursive functions involving redundant computations but compromise code readability and maintainability. It would help if you only used it with strong factual evidence on real business case scenarios. strong factual evidence real Sample Code Wrong memo = {}
def factorial_with_memo(n):
    if n in memo:
        return memo[n]
    if n == 0:
        return 1
    result = n * factorial_with_memo(n-1)
    memo[n] = result
    return result
  
  # This function optimizes the computation of factorials
  # by storing previously computed values,
  # reducing redundant calculations 
  # and improving performance for large inputs. memo = {}
def factorial_with_memo(n):
    if n in memo:
        return memo[n]
    if n == 0:
        return 1
    result = n * factorial_with_memo(n-1)
    memo[n] = result
    return result
  
  # This function optimizes the computation of factorials
  # by storing previously computed values,
  # reducing redundant calculations 
  # and improving performance for large inputs. Right def factorial(n):
    if n == 0:
        return 1
    return n * factorial(n-1) def factorial(n):
    if n == 0:
        return 1
    return n * factorial(n-1) Detection [x]Semi-Automatic [x] Semi-Automatic [x] You can search for all places where you are using this technique and validate if they are worth it. Exceptions Real performance problems with strong factual evidence Real performance problems with strong factual evidence Tags Premature Optimization Premature Optimization Level [x]Intermediate [x] Intermediate [x] AI Generation Unless you explicitly ask the IAs to use this technique, they will suggest cleaner solutions. AI Detection ChatGPT, Gemini, and Claude.ai detect some problems with this technique but do not mention readability as a concern. Claude.ai Conclusion It would be best if you kept a balance between performance optimization and code clarity. You can consider alternatives such as iterative approaches or algorithmic optimizations since memoization significantly compromises code readability. Relations Code Smell 06 - Too Clever Programmer Code Smell 06 - Too Clever Programmer Code Smell 20 - Premature Optimization Code Smell 20 - Premature Optimization More Info Wikipedia Wikipedia Disclaimer Code Smells are my opinion . opinion Credits Photo by Steffen Lemmerzahl on Unsplash Steffen Lemmerzahl Unsplash A cache with a bad policy is another name for a memory leak. A cache with a bad policy is another name for a memory leak. Rico Mariani Rico Mariani Software Engineering Great Quotes Software Engineering Great Quotes This article is part of the CodeSmell Series. How to Find the Stinky Parts of your Code How to Find the Stinky Parts of your Code

Stories, News & Mentions about TAPPLY

Tapply’s Stories on HackerNoon