Dame Angela McLean has been actively contributing to the government’s preparations for November's global AI conference at Bletchley Park in her role as No10's chief scientific adviser

Covid Inquiry: Chief scientist who called Rishi Sunak ‘Dr Death’ now working with PM on AI summit

Video: Professor of medicine told he was called 'f**kwit' by pandemic officials

Estate manager Dee Ward, 58, said the river near Killiemuir, Angus, was "scary" and he wanted to raise awareness of climate change. Mr Ward said: "It is quite scary, we get these seasons now where we get really bad storms blowing in from the Atlantic.

Video: River bursts over bridge in Angus Glen

Helena Kwit, age 81, of Des Plaines, IL (Formerly of Lyndon Station, WI), passed away on Sunday, August 27, 2023, at Advocate Lutheran General Hospital. The Mass of Christian Burial will be held ...

Helena Kwit

Vermonters are urged to take steps to protect themselves against mosquito bites, as mosquitoes in Swanton and Alburgh have tested positive for eastern equine encephalitis — a

Mosquitoes in Swanton and Alburgh test for EEE disease; Health department shares prevention tips

"If you dump them out, then those mosquito larvae won't have a chance to become adult mosquitoes that bite humans."

West Nile virus detected in VT mosquitoes; flood water could impact later populations

Increasing demand and developing technologies are driving the Quit Smoking Apps Market's impressive growth trajectory. The market is developing and growing as more companies and customers come to ...

Quit Smoking Apps Market Size, Scope By Key Players-Kwit, Leaf, Mindsciences

As with all talk of an Oasis rapprochement, this angered Noel, who referred to Matty as a “f–king slack-jawed f–kwit.” So, after opening for his own band with a solo “Matty” set after ...

The 1975’s Matty Healy Opens For His Own Band, Responds to Noel Gallagher Diss With Even Spicier Shot

Secondly, Dan Robinson (Dara Robinson Paradigm) presented his latest white paper "Yield Protocol" on creating digital asset yield curves. At the same time, UMA combined this with a live demonstration using tBTC and UMA technology, and using yTokens traded on Uniswap to create a BTC/USD yield curve.

Shiba Inu Highest Market Cap - Chainlink Future Price 2025

Kwit

kwit

Welcome to other chapters of Let’s Understand Chrome V8 In this paper, we’ll talk about the load and execution of bytecode, as well as the kernel code, important data structures, and workflow of the ignition. 1. Builtin We must know builtin before stepping into ignition, because most of the functions of ignition are implemented by builtins. Builtins are built-in functions, builtins can be seen as chunks of code that are executable by the V8 at runtime. The builtins can be implemented using four different methods. Below is an example of TF_BUILTIN. #define TF_BUILTIN(Name, AssemblerBase)                                     \
  class Name##Assembler : public AssemblerBase {                            \
   public:                                                                  \
    using Descriptor = Builtin_##Name##_InterfaceDescriptor;                \
                                                                            \
    explicit Name##Assembler(compiler::CodeAssemblerState* state)           \
        : AssemblerBase(state) {}                                           \
    void Generate##Name##Impl();                                            \
                                                                            \
    template <class T>                                                      \
    TNode<T> Parameter(                                                     \
        Descriptor::ParameterIndices index,                                 \
        cppgc::SourceLocation loc = cppgc::SourceLocation::Current()) {     \
      return CodeAssembler::Parameter<T>(static_cast<int>(index), loc);     \
    }                                                                       \
                                                                            \
    template <class T>                                                      \
    TNode<T> UncheckedParameter(Descriptor::ParameterIndices index) {       \
      return CodeAssembler::UncheckedParameter<T>(static_cast<int>(index)); \
    }                                                                       \
  };                                                                        \
  void Builtins::Generate_##Name(compiler::CodeAssemblerState* state) {     \
    Name##Assembler assembler(state);                                       \
    state->SetInitialDebugInformation(#Name, __FILE__, __LINE__);           \
    if (Builtins::KindOf(Builtin::k##Name) == Builtins::TFJ) {              \
      assembler.PerformStackCheck(assembler.GetJSContextParameter());       \
    }                                                                       \
    assembler.Generate##Name##Impl();                                       \
  }                                                                         \
  void Name##Assembler::Generate##Name##Impl() In the above code, AssemblerBase is the parent class of this Builtin. The parent of different Builtins are also different. Below is an example. TF_BUILTIN(CloneFastJSArrayFillingHoles, ArrayBuiltinsAssembler) {
  auto context = Parameter<Context>(Descriptor::kContext);
  auto array = Parameter<JSArray>(Descriptor::kSource);

  CSA_ASSERT(this,
             Word32Or(Word32BinaryNot(IsHoleyFastElementsKindForRead(
                          LoadElementsKind(array))),
                      Word32BinaryNot(IsNoElementsProtectorCellInvalid())));

  Return(CloneFastJSArray(context, array, base::nullopt,
                          HoleConversionMode::kConvertToUndefined));
} In the above builtin, the CloneFastJSArrayFillingHoles is the class name, the ArrayBuiltinsAssembler is the parent. The parent is different for each builtin, but they all inherit from the same base class CodeStubAssembler. class V8_EXPORT_PRIVATE CodeStubAssembler
    : public compiler::CodeAssembler,
      public TorqueGeneratedExportedMacrosAssembler {
 public:
  using ScopedExceptionHandler = compiler::ScopedExceptionHandler;

  template <typename T>
  using LazyNode = std::function<TNode<T>()>;

  explicit CodeStubAssembler(compiler::CodeAssemblerState* state);

  enum AllocationFlag : uint8_t {
    kNone = 0,
    kDoubleAlignment = 1,
    kPretenured = 1 << 1,
    kAllowLargeObjectAllocation = 1 << 2,
  };

  enum SlackTrackingMode { kWithSlackTracking, kNoSlackTracking };

  using AllocationFlags = base::Flags<AllocationFlag>;

  TNode<IntPtrT> ParameterToIntPtr(TNode<Smi> value) { return SmiUntag(value); }
  TNode<IntPtrT> ParameterToIntPtr(TNode<IntPtrT> value) { return value; }
  TNode<IntPtrT> ParameterToIntPtr(TNode<UintPtrT> value) {
    return Signed(value);
  }

  enum InitializationMode {
    kUninitialized,
    kInitializeToZero,
    kInitializeToNull
  };
//........................
//omit
//........................ Below is the builtin list, it contains all the builtins. #define BUILTIN_LIST(CPP, TFJ, TFC, TFS, TFH, BCH, ASM)  \
  BUILTIN_LIST_BASE(CPP, TFJ, TFC, TFS, TFH, ASM)        \
  BUILTIN_LIST_FROM_TORQUE(CPP, TFJ, TFC, TFS, TFH, ASM) \
  BUILTIN_LIST_INTL(CPP, TFJ, TFS)                       \
  BUILTIN_LIST_BYTECODE_HANDLERS(BCH) This paper does not cover the grammar of builtin, please reach out to me if you want to know more. Unfortunately, we can only see the assembly source code when debugging builtin, because the implementation of builtin is separated from V8 and stored in the file, which does not include the builtin symbol table. snapshot_blob.bin InterpreterEntryTrampoline is the starting point for executing bytecode, let’s talk about how to debug bytecode. enum class Builtin : int32_t {
  kNoBuiltinId = -1,
#define DEF_ENUM(Name, ...) k##Name,
  BUILTIN_LIST(DEF_ENUM, DEF_ENUM, DEF_ENUM, DEF_ENUM, DEF_ENUM, DEF_ENUM,
               DEF_ENUM)
#undef DEF_ENUM
#define EXTRACT_NAME(Name, ...) k##Name,
  // Define kFirstBytecodeHandler,
  kFirstBytecodeHandler =
      FirstFromVarArgs(BUILTIN_LIST_BYTECODE_HANDLERS(EXTRACT_NAME) 0)
#undef EXTRACT_NAME
}; In the above enumeration class, each builtin has an index. According to the order of the BUILTIN_LIST macro template, we can calculate the InterpreterEntryTrampoline’s index. Find the corresponding element in the isolate->isolate_data_.builtins_ array, as shown in Figure 1. This element holds the memory address of the InterpreterEntryTrampoline. With this address, we can use memory breakpoints for debugging. Another way is to debug from the i::Excetuion::Call(), which also goes into InterpreterEntryTrampoline eventually. 2. Ignition Ignition is the V8 interpreter, responsible for executing bytecode, its input is a bytecode array, and the output is the result of the program. Here are some important concepts: bytecode handler: bytecode handlers, one handler for each bytecode. bytecode array: An array of bytecodes is generated from a piece of JS (usually a JS function) compiled. dispatch: bytecode dispatcher, same as EIP register. dispatch table: This table holds the address of the bytecode. Below is the source code of InterpreterEntryTrampoline. 1.  void Builtins::Generate_InterpreterEntryTrampoline(MacroAssembler* masm) {
2.    Register closure = rdi;
3.    Register feedback_vector = rbx;
4.    // Get the bytecode array from the function object and load it into
5.    // kInterpreterBytecodeArrayRegister.
6.    __ LoadTaggedPointerField(
7.        kScratchRegister,
8.        FieldOperand(closure, JSFunction::kSharedFunctionInfoOffset));
9.    __ LoadTaggedPointerField(
10.        kInterpreterBytecodeArrayRegister,
11.        FieldOperand(kScratchRegister, SharedFunctionInfo::kFunctionDataOffset));
12.    Label is_baseline;
13.    GetSharedFunctionInfoBytecodeOrBaseline(
14.        masm, kInterpreterBytecodeArrayRegister, kScratchRegister, &is_baseline);
15.    // The bytecode array could have been flushed from the shared function info,
16.    // if so, call into CompileLazy.
17.    Label compile_lazy;
18.    __ CmpObjectType(kInterpreterBytecodeArrayRegister, BYTECODE_ARRAY_TYPE,
19.                     kScratchRegister);
20.    __ j(not_equal, &compile_lazy);
21.    // Load the feedback vector from the closure.
22.    __ LoadTaggedPointerField(
23.        feedback_vector, FieldOperand(closure, JSFunction::kFeedbackCellOffset));
24.    __ LoadTaggedPointerField(feedback_vector,
25.                              FieldOperand(feedback_vector, Cell::kValueOffset));
26.  //omit
27.  } The role of InterpreterEntryTrampoline includes building stacks, allocating local variables, etc. Figure 2 is a detailed description. The 13th line, the GetSharedFunctionInfoBytecodeOrBaseline takes out the bytecode array, and then calls the first bytecode of the bytecode array. There are also some important functions in the builtins class, as below. 1.  class Builtins {
2.  //.......omit.................
3.    static void Generate_CallOrConstructVarargs(MacroAssembler* masm,
4.                                                Handle<Code> code);
5.    static void Generate_CallOrConstructForwardVarargs(MacroAssembler* masm,
6.                                                       CallOrConstructMode mode,
7.                                                       Handle<Code> code);
8.    static void Generate_InterpreterPushArgsThenCallImpl(
9.        MacroAssembler* masm, ConvertReceiverMode receiver_mode,
10.        InterpreterPushArgsMode mode);
11.    static void Generate_InterpreterPushArgsThenConstructImpl(
12.        MacroAssembler* masm, InterpreterPushArgsMode mode);
13.    template <class Descriptor>
14.    static void Generate_DynamicCheckMapsTrampoline(MacroAssembler* masm,
15.                                                    Handle<Code> builtin_target);
16.  #define DECLARE_ASM(Name, ...) \
17.    static void Generate_##Name(MacroAssembler* masm);
18.  #define DECLARE_TF(Name, ...) \
19.    static void Generate_##Name(compiler::CodeAssemblerState* state);
20.    BUILTIN_LIST(IGNORE_BUILTIN, DECLARE_TF, DECLARE_TF, DECLARE_TF, DECLARE_TF,
21.                 IGNORE_BUILTIN, DECLARE_ASM)
22.  //......omit............ Lines 16 and 17, DECLARE_TF and DECLARE_ASM are the generation templates for builtins. bytecode is a subclass of builtin, and V8 has many kinds of builtins. bytecode is builtin, but builtin is not all bytecode. Note: The bytecode handler generation template is below. #define IGNITION_HANDLER(Name, BaseAssembler)                         \
  class Name##Assembler : public BaseAssembler {                      \
   public:                                                            \
    explicit Name##Assembler(compiler::CodeAssemblerState* state,     \
                             Bytecode bytecode, OperandScale scale)   \
        : BaseAssembler(state, bytecode, scale) {}                    \
    Name##Assembler(const Name##Assembler&) = delete;                 \
    Name##Assembler& operator=(const Name##Assembler&) = delete;      \
    static void Generate(compiler::CodeAssemblerState* state,         \
                         OperandScale scale);                         \
                                                                      \
   private:                                                           \
    void GenerateImpl();                                              \
  };                                                                  \
  void Name##Assembler::Generate(compiler::CodeAssemblerState* state, \
                                 OperandScale scale) {                \
    Name##Assembler assembler(state, Bytecode::k##Name, scale);       \
    state->SetInitialDebugInformation(#Name, __FILE__, __LINE__);     \
    assembler.GenerateImpl();                                         \
  }                                                                   \
  void Name##Assembler::GenerateImpl()

//====================separation=================================
// LdaZero
// Load literal '0' into the accumulator.
IGNITION_HANDLER(LdaZero, InterpreterAssembler) {
  TNode<Number> zero_value = NumberConstant(0.0);
  SetAccumulator(zero_value);
  Dispatch();
} IGNITION_HANDLER is the macro template, Name is the bytecode name, and BaseAssembler is the parent class of the bytecode. IGNITION_HANDLER(LdaZero, InterpreterAssembler) generates LdaZero’s handler. The source code of Dispatch() is below. 1.  void InterpreterAssembler::Dispatch() {
2.    Comment("========= Dispatch");
3.    DCHECK_IMPLIES(Bytecodes::MakesCallAlongCriticalPath(bytecode_), made_call_);
4.    TNode<IntPtrT> target_offset = Advance();
5.    TNode<WordT> target_bytecode = LoadBytecode(target_offset);
6.    DispatchToBytecodeWithOptionalStarLookahead(target_bytecode);
7.  }
8.  void InterpreterAssembler::DispatchToBytecodeWithOptionalStarLookahead(
9.      TNode<WordT> target_bytecode) {
10.    if (Bytecodes::IsStarLookahead(bytecode_, operand_scale_)) {
11.      StarDispatchLookahead(target_bytecode);
12.    }
13.    DispatchToBytecode(target_bytecode, BytecodeOffset());
14.  } Line 5, LoadBytecode takes out the next bytecode. Line 8, DispatchToBytecodeWithOptionalStarLookahead jumps to the next bytecode. The entry for generating bytecode handler is below. Handle<Code> GenerateBytecodeHandler(Isolate* isolate, const char* debug_name,
                                     Bytecode bytecode,
                                     OperandScale operand_scale,
                                     Builtin builtin,
                                     const AssemblerOptions& options) {
  Zone zone(isolate->allocator(), ZONE_NAME, kCompressGraphZone);
  compiler::CodeAssemblerState state(
      isolate, &zone, InterpreterDispatchDescriptor{},
      CodeKind::BYTECODE_HANDLER, debug_name,
      builtin);

  switch (bytecode) {
#define CALL_GENERATOR(Name, ...)                     \
  case Bytecode::k##Name:                             \
    Name##Assembler::Generate(&state, operand_scale); \
    break;
    BYTECODE_LIST_WITH_UNIQUE_HANDLERS(CALL_GENERATOR);
#undef CALL_GENERATOR
    case Bytecode::kIllegal:
      IllegalAssembler::Generate(&state, operand_scale);
      break;
    case Bytecode::kStar0:
      Star0Assembler::Generate(&state, operand_scale);
      break;
    default:
      UNREACHABLE();
  }
//............omit
} GenerateBytecodeHandler is the entry, which is responsible for calling the IGNITION_HANDLER(XXX, YYY) macro template to generate full bytecode handlers. Okay, that wraps it up for this share. I’ll see you guys next time, take care! Please reach out to me if you have any issues. : qq9123013 : v8blink@outlook.com WeChat Email Also published . here

Let’s Understand Chrome V8 — Chapter 8: V8 Interpreter Ignition

In the ever-evolving landscape of mobile app development, the ability to process and analyse images in real time has become increasingly important. If you are a Flutter developer you must have relied on the google ml kit for flutter to bring powerful machine learning capabilities to their apps. Today, I’m excited to announce a significant enhancement to this package with the addition of subject segmentation. Subject segmentation allows developers to easily separate multiple subjects from the background in a picture, enabling use cases such as sticker creation, background swap, or adding cool effects to subjects. Subject refers to the primary people, animals, or objects that appear in the foreground of an image. If you have two subjects very close or touching each other, they are considered a single subject. The subject segmentation processes an input image and produces an output mask or bitmap for the foreground. If you are new to theGoogle ML Kit Flutter, it is a set of Flutter plugins that enable Flutter apps to use Google’s standalone ML Kit, making it easy to use these powerful ML features in Flutter apps. Before this addition, google_ml_kit for Flutter already offered a range of capabilities including text recognition, face detection, pose estimation and more. These features have enabled developers to create sophisticated apps with minimal effort in implementing complex ML algorithms. Using Subject Segmentation on your Flutter app To use the new subject segmentation on your app, you can follow these simple steps Firstly, what are the requirements? iOS: This feature is still in Beta, and it is only available for Android. Stay tuned for updates on Google’s website and request the feature here Android minSdkVersion: 24
targetSdkVersion: 33
complieSdkVersion: 34 You can configure your app to automatically download the model to the device after your app is installed from the Play Store. To do so, add the following declaration to your app’s AndroidManifest.xml file: <application ...>
      ...
      <meta-data
          android:name="com.google.mlkit.vision.DEPENDENCIES"
          android:value="subject_segment" >
      
</application> Secondly, update your pubspec.yaml file by adding the google_ml_kit_subject_segmentation and running an implicit flutter pub get dependencies:
  google_mlkit_subject_segmentation: ^0.0.1 Or run this command on your terminal flutter pub add google_mlkit_subject_segmentation Now in our Dart code, you can use: import 'package:google_mlkit_subject_segmentation/google_mlkit_subject_segmentation.dart'; Usage Create an instance of InputImage with either of these three ways: From path: final inputImage = InputImage.fromFilePath(filePath); From file: final inputImage = InputImage.fromFile(file); From bytes: final inputImage = InputImage.fromBytes(bytes: bytes, metadata: metadata); Create an instance of SubjectSegmenter final options = SubjectSegmenterOptions(
    enableForegroundConfidenceMask: true,
    enableForegroundBitmap: false,
    enableMultipleSubjects: SubjectResultOptions(
      enableConfidenceMask: false,
      enableSubjectBitmap: false,
    ),
  );

final segmenter = SubjectSegmenter(options: options); Let’s discuss the options. We have four of them. Don’t worry; I will explain them one after the other. Foreground confidence mask The foreground confidence mask lets you distinguish the foreground subject from the background. To enable the confidence mask, you have to pass true to enableForegroundConfidenceMask enableForegroundConfidenceMask: true Foreground bitmap Similarly, you can also get a bitmap of the foreground subject, To enable that you have to passtrue to enableForegroundBitmap enableForegroundBitmap: true, Multi-subject confidence mask As for the foreground options, you can use the SubjectResultOptions to enable the confidence mask for each foreground subject as follows: SubjectResultOptions(
      enableConfidenceMask: true,
      enableSubjectBitmap: false,
    ) Multi-subject bitmap Similarly, you can enable the bitmap for each subject: SubjectResultOptions(
      enableConfidenceMask: false,
      enableSubjectBitmap: true,
    ) Process image final result = await segmenter.processImage(inputImage); Release resources with close segmenter.close(); https://vimeo.com/1019321142 In the example above, I used the Foreground Bitmap you can also check the source code below https://github.com/bensonarafat/subject_segmentation?source=post_page-----e1a954e7ec09-------------------------------- I can’t wait to see what you all build with this. Cheers 🍻 🥂. In the ever-evolving landscape of mobile app development, the ability to process and analyse images in real time has become increasingly important. If you are a Flutter developer you must have relied on the google ml kit for flutter to bring powerful machine learning capabilities to their apps. Today, I’m excited to announce a significant enhancement to this package with the addition of subject segmentation. google ml kit for flutter google ml kit for flutter Subject segmentation allows developers to easily separate multiple subjects from the background in a picture, enabling use cases such as sticker creation, background swap, or adding cool effects to subjects. Subject segmentation Subject segmentation Subject refers to the primary people, animals, or objects that appear in the foreground of an image. If you have two subjects very close or touching each other, they are considered a single subject. The subject segmentation processes an input image and produces an output mask or bitmap for the foreground. If you are new to the Google ML Kit Flutter , it is a set of Flutter plugins that enable Flutter apps to use Google’s standalone ML Kit , making it easy to use these powerful ML features in Flutter apps. Google ML Kit Flutter Google ML Kit Flutter Google’s standalone ML Kit Google’s standalone ML Kit Before this addition, google_ml_kit for Flutter already offered a range of capabilities including text recognition, face detection, pose estimation and more. These features have enabled developers to create sophisticated apps with minimal effort in implementing complex ML algorithms. Using Subject Segmentation on your Flutter app To use the new subject segmentation on your app, you can follow these simple steps Firstly, what are the requirements? iOS: This feature is still in Beta, and it is only available for Android. Stay tuned for updates on Google’s website and request the feature here iOS: This feature is still in Beta, and it is only available for Android. Stay tuned for updates on Google’s website and request the feature here iOS: This feature is still in Beta, and it is only available for Android. Stay tuned for updates on Google’s website and request the feature here Google’s website Google’s website here here Android minSdkVersion: 24 targetSdkVersion: 33 complieSdkVersion: 34 minSdkVersion: 24 targetSdkVersion: 33 complieSdkVersion: 34 You can configure your app to automatically download the model to the device after your app is installed from the Play Store. To do so, add the following declaration to your app’s AndroidManifest.xml file: AndroidManifest.xml <application ...>
      ...
      <meta-data
          android:name="com.google.mlkit.vision.DEPENDENCIES"
          android:value="subject_segment" >
      
</application> <application ...>
      ...
      <meta-data
          android:name="com.google.mlkit.vision.DEPENDENCIES"
          android:value="subject_segment" >
      
</application> Secondly, update your pubspec.yaml file by adding the google_ml_kit_subject_segmentation and running an implicit flutter pub get pubspec.yaml google_ml_kit_subject_segmentation google_ml_kit_subject_segmentation flutter pub get dependencies:
  google_mlkit_subject_segmentation: ^0.0.1 dependencies:
  google_mlkit_subject_segmentation: ^0.0.1 Or run this command on your terminal flutter pub add google_mlkit_subject_segmentation flutter pub add google_mlkit_subject_segmentation Now in our Dart code, you can use: import 'package:google_mlkit_subject_segmentation/google_mlkit_subject_segmentation.dart'; import 'package:google_mlkit_subject_segmentation/google_mlkit_subject_segmentation.dart'; Usage Create an instance of InputImage with either of these three ways: InputImage From path: final inputImage = InputImage.fromFilePath(filePath); final inputImage = InputImage.fromFilePath(filePath); From file: final inputImage = InputImage.fromFile(file); final inputImage = InputImage.fromFile(file); From bytes: final inputImage = InputImage.fromBytes(bytes: bytes, metadata: metadata); final inputImage = InputImage.fromBytes(bytes: bytes, metadata: metadata); Create an instance of SubjectSegmenter SubjectSegmenter final options = SubjectSegmenterOptions(
    enableForegroundConfidenceMask: true,
    enableForegroundBitmap: false,
    enableMultipleSubjects: SubjectResultOptions(
      enableConfidenceMask: false,
      enableSubjectBitmap: false,
    ),
  );

final segmenter = SubjectSegmenter(options: options); final options = SubjectSegmenterOptions(
    enableForegroundConfidenceMask: true,
    enableForegroundBitmap: false,
    enableMultipleSubjects: SubjectResultOptions(
      enableConfidenceMask: false,
      enableSubjectBitmap: false,
    ),
  );

final segmenter = SubjectSegmenter(options: options); Let’s discuss the options. We have four of them. Don’t worry; I will explain them one after the other. discuss the options. We have four of them. Don’t worry; I will explain them one after the other. Foreground confidence mask Foreground confidence mask The foreground confidence mask lets you distinguish the foreground subject from the background. To enable the confidence mask, you have to pass true to enableForegroundConfidenceMask true true enableForegroundConfidenceMask enableForegroundConfidenceMask enableForegroundConfidenceMask: true enableForegroundConfidenceMask: true Foreground bitmap Similarly, you can also get a bitmap of the foreground subject, To enable that you have to pass true to enableForegroundBitmap true true enableForegroundBitmap enableForegroundBitmap enableForegroundBitmap: true, enableForegroundBitmap: true, Multi-subject confidence mask As for the foreground options, you can use the SubjectResultOptions to enable the confidence mask for each foreground subject as follows: SubjectResultOptions SubjectResultOptions SubjectResultOptions(
      enableConfidenceMask: true,
      enableSubjectBitmap: false,
    ) SubjectResultOptions(
      enableConfidenceMask: true,
      enableSubjectBitmap: false,
    ) Multi-subject bitmap Similarly, you can enable the bitmap for each subject: SubjectResultOptions(
      enableConfidenceMask: false,
      enableSubjectBitmap: true,
    ) SubjectResultOptions(
      enableConfidenceMask: false,
      enableSubjectBitmap: true,
    ) Process image final result = await segmenter.processImage(inputImage); final result = await segmenter.processImage(inputImage); Release resources with close segmenter.close(); segmenter.close(); https://vimeo.com/1019321142 https://vimeo.com/1019321142 In the example above, I used the Foreground Bitmap you can also check the source code below Foreground Bitmap Foreground Bitmap https://github.com/bensonarafat/subject_segmentation?source=post_page-----e1a954e7ec09-------------------------------- https://github.com/bensonarafat/subject_segmentation?source=post_page-----e1a954e7ec09-------------------------------- I can’t wait to see what you all build with this. Cheers 🍻 🥂.

Elevate Your Flutter App: A Guide to Subject Segmentation Using Google ML Kit

You’ve probably heard countless times that when it comes to prompting—whether on ChatGPT, MidJourney, Synthesia, Runway ML, or any other AI tool—being as precise as possible is key. The first step toward precision is detail. AI, as we know it, is not a mind reader; it works solely based on the information you provide. Only with clear, detailed input can you achieve the best results. This principle also applies when generating precise images. However, in this case, when prompting, you need to think like a photographer, a designer, and a writer all at once. In this article, we’ll explore how to write effective prompts for Google's AI Test Kitchen ImageFX to get accurate results. First of all, the Don't of AI Test Kitchen Image FX ImageFX does not allow queries that could lead to outputs involving minors or certain prominent individuals.
It also discourages queries that result in images portraying abuse, violence, self-harm, or any content promoting hatred. Why Does Precision Matter? Precision can mean the difference between a flawed result and a perfectly executed output, especially when generating images. Text prompts might offer vague summaries, but poorly structured image prompts can drastically affect the outcome. If, like me, you’re creating for a non-Caucasian audience, you must be extremely precise. A vague prompt will likely produce generic, unusable results. However, when done correctly, ImageFX excels at generating region-specific outputs tailored to your needs. Crafting Effective Prompts: A Step-by-Step Guide When crafting an image prompt, keep these three key components in mind: 1. Who Is Your Subject Matter? Suppose you’re conceptualizing an image of a "woman in a coffee shop." In this case, the woman is the subject. It’s essential to clearly define your subject, depending on the audience and your intention. See the difference between both prompts. Prompt 1: A woman in a coffee shop. Prompt 2: A plump Nigerian woman sitting in a coffee shop. 2. Be Descriptive and Detailed In other words "show workings." What actions are the characters performing? What time of day is it? What is the mood? Describe the setting, the characters’ outfits, any secondary subjects, and the overall atmosphere. Example: A plump Nigerian woman sitting in a coffee shop, sipping coffee. On the table is a book and an iPhone and seated beside her is a Pomeranian. 3. Be Specific About the Composition and Style This is where you need to think like a designer. Consider the layout and style. Do you want an animated style? If so, what kind? Do you want it to be animated and if yes what kind of animation - Traditional Animation (2D, Hand-Drawn Animation) or 3D Animation (CGI)? Luckily, if you are looking to adopt a particular style of animation that you like, ImageFX allows you to experiment with different animation styles. Prompt A plump Nigerian woman sitting in a coffee shop, sipping coffee. On the table is a book and an iPhone and seated beside her is a Pomeranian. They are all in Pixar animated style. A plump Nigerian woman sitting in a coffee shop, sipping coffee. On the table is a book and an iPhone and seated beside her is a Pomeranian. They are all in Simpson's animated style. To get into a photographer's mindset, you have to consider the angles, the lighting, and the focus of the shot. Prompts with Various Angles: 1. Close-up (Focus on the Woman and Coffee Sip) Close-up shot of a plump Nigerian woman lifting her coffee cup toward her lips, taking a slow sip. Her face shows a relaxed expression. On the table in front of her, a book lies open next to an iPhone, partially in view. A Pomeranian sits quietly beside her, peeking into the frame. 2. Over-the-shoulder (Focus on the Table and Scene) Over-the-shoulder shot from behind a plump Nigerian woman, capturing the scene from her perspective. The table shows an open book and her iPhone lying beside it. The Pomeranian is seated next to her, with the coffee shop atmosphere visible in the background. 3. Wide-angle (Full Room View of the Scene) Wide-angle shot showing the entire coffee shop scene: a plump Nigerian woman sitting at a table, sipping coffee, with her book and iPhone lying in front of her. A Pomeranian is seated by her side, looking calm. The café setting includes soft lighting, other customers, and a warm ambiance. 4. Bird’s-eye View (Top-down Perspective of the Table) Bird’s-eye view from directly above the table shows the entire scene: an open book, an iPhone, and a coffee cup on a table. A Pomeranian is seated beside a plump Nigerian woman, while she is sipping her coffee, creating a peaceful, content moment captured from above. 5. Medium Shot (Balanced View of the Woman, Table, and Pomeranian) Medium shot from the side, showing a plump Nigerian woman comfortably sitting in the coffee shop, sipping her coffee. A table is visible with the open book and iPhone laid out, and a Pomeranian is seated next to her, calmly watching the surroundings. The warm lighting of the coffee shop adds to the ambiance. 6. Side Profile (Highlighting the Woman and the Pet) Side profile shot of a plump Nigerian woman sitting at a table, sipping her coffee, with a book open in front of her and the iPhone placed nearby. A Pomeranian is seated beside her, either looking toward her or gazing ahead. The coffee shop's interior provides a soft, cozy backdrop. 7. Close-up (Focus on the Pomeranian) Close-up shot of a Pomeranian seated on the chair beside a woman, looking calm and content. In the blurred background, a plump Nigerian woman can be seen sipping her coffee with the book and iPhone on the table. 9. Overhead Angle (Showcasing Coffee, Book, and Phone) Overhead angle shot that captures a plump Nigerian woman’s hand holding the coffee cup as she lifts it to take a sip. A book lies open on the table with an iPhone next to it, creating a top-down view of the table setup. A Pomeranian is just visible seated beside her, rounding out the scene. Tips for Getting the Best Results on ImageFX Experiment with Keywords: Don’t hesitate to try different keyword combinations. ImageFX might be restrictive, but with the right prompts, you can achieve close-to-ideal results.
Maintain Consistency: When creating a series of images, keep the angle and style consistent. Only change the subject when necessary.
Use Identifiers: When generating multiple images with the same subject, give the subject unique identifiers to maintain flow. Troubleshooting Common Issues with ImageFX Query: "I’m a Nigerian creating for a Nigerian audience, but some details are off." Response: AI isn’t a mind reader. You need to adjust your descriptors for more accurate results. Example: Prompt 1: A Nigerian conductor in front of a bus. Prompt 2: A Nigerian Lagos conductor wearing shorts and a tank top in front of a yellow Danfo bus (Volkswagen T3). Conclusion While you don’t need to be a prolific writer to craft effective prompts, you do need to take the time to clearly and descriptively outline what you want. Don’t be discouraged if the result isn’t perfect on the first try—keep experimenting, adding or removing keywords as needed. And with that I leave you with these images I conceptualised using ImageFX. Enjoy. You’ve probably heard countless times that when it comes to prompting—whether on ChatGPT, MidJourney, Synthesia, Runway ML, or any other AI tool—being as precise as possible is key. The first step toward precision is detail. AI, as we know it, is not a mind reader; it works solely based on the information you provide. Only with clear, detailed input can you achieve the best results. This principle also applies when generating precise images. However, in this case, when prompting, you need to think like a photographer, a designer, and a writer all at once. In this article, we’ll explore how to write effective prompts for Google's AI Test Kitchen ImageFX to get accurate results. First of all, the Don't of AI Test Kitchen Image FX First of all, the Don't of AI Test Kitchen Image FX ImageFX does not allow queries that could lead to outputs involving minors or certain prominent individuals. It also discourages queries that result in images portraying abuse, violence, self-harm, or any content promoting hatred. ImageFX does not allow queries that could lead to outputs involving minors or certain prominent individuals. It also discourages queries that result in images portraying abuse, violence, self-harm, or any content promoting hatred. Why Does Precision Matter? Why Does Precision Matter? Precision can mean the difference between a flawed result and a perfectly executed output, especially when generating images. Text prompts might offer vague summaries, but poorly structured image prompts can drastically affect the outcome. If, like me, you’re creating for a non-Caucasian audience, you must be extremely precise. A vague prompt will likely produce generic, unusable results. However, when done correctly, ImageFX excels at generating region-specific outputs tailored to your needs. Crafting Effective Prompts: A Step-by-Step Guide When crafting an image prompt, keep these three key components in mind: 1. Who Is Your Subject Matter? Suppose you’re conceptualizing an image of a "woman in a coffee shop." In this case, the woman is the subject. It’s essential to clearly define your subject, depending on the audience and your intention. See the difference between both prompts. Prompt 1: A woman in a coffee shop. Prompt 1: A woman in a coffee shop. Prompt 2: A plump Nigerian woman sitting in a coffee shop. Prompt 2: A plump Nigerian woman sitting in a coffee shop. 2. Be Descriptive and Detailed 2. Be Descriptive and Detailed In other words "show workings." What actions are the characters performing? What time of day is it? What is the mood? Describe the setting, the characters’ outfits, any secondary subjects, and the overall atmosphere. "show workings." Example: A plump Nigerian woman sitting in a coffee shop, sipping coffee. On the table is a book and an iPhone and seated beside her is a Pomeranian. 3. Be Specific About the Composition and Style 3. Be Specific About the Composition and Style This is where you need to think like a designer. Consider the layout and style. Do you want an animated style? If so, what kind? Do you want it to be animated and if yes what kind of animation - Traditional Animation (2D, Hand-Drawn Animation) or 3D Animation (CGI)? Luckily, if you are looking to adopt a particular style of animation that you like, ImageFX allows you to experiment with different animation styles. Prompt A plump Nigerian woman sitting in a coffee shop, sipping coffee. On the table is a book and an iPhone and seated beside her is a Pomeranian. They are all in Pixar animated style. A plump Nigerian woman sitting in a coffee shop, sipping coffee. On the table is a book and an iPhone and seated beside her is a Pomeranian. They are all in Simpson's animated style. To get into a photographer's mindset, you have to consider the angles, the lighting, and the focus of the shot. To get into a photographer's mindset, you have to consider the angles, the lighting, and the focus of the shot. Prompts with Various Angles: 1. Close-up (Focus on the Woman and Coffee Sip) 1. Close-up (Focus on the Woman and Coffee Sip) Close-up shot of a plump Nigerian woman lifting her coffee cup toward her lips, taking a slow sip. Her face shows a relaxed expression. On the table in front of her, a book lies open next to an iPhone, partially in view. A Pomeranian sits quietly beside her, peeking into the frame. 2. Over-the-shoulder (Focus on the Table and Scene) 2. Over-the-shoulder (Focus on the Table and Scene) Over-the-shoulder shot from behind a plump Nigerian woman, capturing the scene from her perspective. The table shows an open book and her iPhone lying beside it. The Pomeranian is seated next to her, with the coffee shop atmosphere visible in the background. 3. Wide-angle (Full Room View of the Scene) 3. Wide-angle (Full Room View of the Scene) Wide-angle shot showing the entire coffee shop scene: a plump Nigerian woman sitting at a table, sipping coffee, with her book and iPhone lying in front of her. A Pomeranian is seated by her side, looking calm. The café setting includes soft lighting, other customers, and a warm ambiance. 4. Bird’s-eye View (Top-down Perspective of the Table) 4. Bird’s-eye View (Top-down Perspective of the Table) Bird’s-eye view from directly above the table shows the entire scene: an open book, an iPhone, and a coffee cup on a table. A Pomeranian is seated beside a plump Nigerian woman, while she is sipping her coffee, creating a peaceful, content moment captured from above. 5. Medium Shot (Balanced View of the Woman, Table, and Pomeranian) 5. Medium Shot (Balanced View of the Woman, Table, and Pomeranian) Medium shot from the side, showing a plump Nigerian woman comfortably sitting in the coffee shop, sipping her coffee. A table is visible with the open book and iPhone laid out, and a Pomeranian is seated next to her, calmly watching the surroundings. The warm lighting of the coffee shop adds to the ambiance. 6. Side Profile (Highlighting the Woman and the Pet) 6. Side Profile (Highlighting the Woman and the Pet) Side profile shot of a plump Nigerian woman sitting at a table, sipping her coffee, with a book open in front of her and the iPhone placed nearby. A Pomeranian is seated beside her, either looking toward her or gazing ahead. The coffee shop's interior provides a soft, cozy backdrop. 7. Close-up (Focus on the Pomeranian) 7. Close-up (Focus on the Pomeranian) Close-up shot of a Pomeranian seated on the chair beside a woman, looking calm and content. In the blurred background, a plump Nigerian woman can be seen sipping her coffee with the book and iPhone on the table. 9. Overhead Angle (Showcasing Coffee, Book, and Phone) 9. Overhead Angle (Showcasing Coffee, Book, and Phone) Overhead angle shot that captures a plump Nigerian woman’s hand holding the coffee cup as she lifts it to take a sip. A book lies open on the table with an iPhone next to it, creating a top-down view of the table setup. A Pomeranian is just visible seated beside her, rounding out the scene. Tips for Getting the Best Results on ImageFX Experiment with Keywords: Don’t hesitate to try different keyword combinations. ImageFX might be restrictive, but with the right prompts, you can achieve close-to-ideal results. Maintain Consistency: When creating a series of images, keep the angle and style consistent. Only change the subject when necessary. Use Identifiers: When generating multiple images with the same subject, give the subject unique identifiers to maintain flow. Experiment with Keywords: Don’t hesitate to try different keyword combinations. ImageFX might be restrictive, but with the right prompts, you can achieve close-to-ideal results. Maintain Consistency: When creating a series of images, keep the angle and style consistent. Only change the subject when necessary. Use Identifiers: When generating multiple images with the same subject, give the subject unique identifiers to maintain flow. Troubleshooting Common Issues with ImageFX Query: "I’m a Nigerian creating for a Nigerian audience, but some details are off." Response: AI isn’t a mind reader. You need to adjust your descriptors for more accurate results. Example: Prompt 1: A Nigerian conductor in front of a bus. Prompt 1: A Nigerian conductor in front of a bus. Prompt 2: A Nigerian Lagos conductor wearing shorts and a tank top in front of a yellow Danfo bus (Volkswagen T3). Prompt 2: Conclusion Conclusion While you don’t need to be a prolific writer to craft effective prompts, you do need to take the time to clearly and descriptively outline what you want. Don’t be discouraged if the result isn’t perfect on the first try—keep experimenting, adding or removing keywords as needed. And with that I leave you with these images I conceptualised using ImageFX. Enjoy.

How to Write Precise Prompts on Google's AI Test Kitchen

Как да напишете прецизни подкани в кухнята за тестване на изкуствен интелект на Google

Com escriure indicacions precises a la cuina de prova d'IA de Google

Cómo escribir indicaciones precisas en la cocina de pruebas de inteligencia artificial de Google

गूगल के AI टेस्ट किचन पर सटीक संकेत कैसे लिखें

Google の AI テスト キッチンで正確なプロンプトを書く方法

Google-ийн хиймэл оюун ухааны туршилтын гал тогоон дээр хэрхэн нарийн сануулгыг бичих вэ

गुगलको एआई टेस्ट किचेनमा कसरी सटीक प्रम्प्टहरू लेख्ने

Tsela ya go Ngwala Ditšhišinyo tše di Nepagetšego go Google ya AI Test Kitchen

Cum să scrieți solicitări precise în bucătăria de testare AI a Google

Sida Looga Qoro Codsiyada Saxda ah ee Google's AI Test Jikada

ከመይ ጌርና ኣብ ናይ Google AI Test Kitchen ልክዕ ምልክታት ንጽሕፍ

گوگل کے اے آئی ٹیسٹ کچن پر درست اشارے کیسے لکھیں۔

Mastering the Art of Data: Lessons From the Kitchen

How to Learn Web Development: HTML, CSS, MERN, and Python - 22 GitHub Repositories to Help You

The Top React UI Components

Top React UI-komponenterne

Los mejores componentes de interfaz de usuario de React

Les meilleurs composants d'interface utilisateur React

トップ React UI コンポーネント

Top React UI компоненттери

Ireo singa UI Top React

Лучшие компоненты пользовательского интерфейса React

ඉහළ ප්‍රතික්‍රියා UI සංරචක

Komponentët Top React UI

Vipengee vya Juu vya UI React

ٹاپ ری ایکٹ UI اجزاء

Amacandelo aphezulu e-UI asabelayo

The world is a much more connected place than it was 20 years ago. With the change came new expectations. Downtimes can cripple businesses. There is an expectation of privacy and security. If we post on Facebook and the post gets lost due to any kind of issue, people will not tolerate it. Data integrity and durability are more critical than ever. As an organization, we must consider multiple technological tenets—security, availability, latency, durability, integrity, reliability, and privacy. We don’t get to choose from this list; we just sort it by importance based on business needs. Business continuity Disaster can come in many flavors, ranging from natural disasters to hardware failures, misconfiguration, and cyberattacks. The problem with cyberattacks is that we risk having our data stolen and wonder if the rest of the data is trustworthy. Maybe the attack was a sleight of hand, and the primary objective was to introduce malicious data that would haunt the organization forever. After the security incident, we need to recover the data and restore the service to the level our customers expect. One of the issues we face is reconstructing the original picture and configuration. We need to understand how all the pieces work together and their interdependency. Data restoration is more than just restoring a highly scalable web service snapshot. Objective At this point, our primary objective should be to ensure that our services are available and reliable by whatever means necessary. In the context of dependency management, we need to have a comprehensive data and dependency catalog, including the relationships between the entities. This provides us with the necessary insight into what exists. We also need regular operations testing and robust disaster recovery through automation and manual runbooks. We need to cultivate a culture of disaster recovery fire drills and identify fallbacks. Maturity Model Like an individual who enters college goes through freshman, sophomore, junior, and senior years before graduating, businesses need to follow a slow, progressive approach. It’s impractical for a company or organization to go from no disaster recovery to a fully-fledged, perfectly fleshed-out plan. The road to success is incremental, and each step builds on the previous step. Maturity models examine an organization’s current state from any specific perspective, such as disaster recovery, and help the organization reach the desired state or capability. As the organization progresses toward the end goal, it goes through various checkpoints, usually called Levels. Most Maturity Models have four levels, starting from Level 1 up to Level 4. Why are we talking about maturity models? One step in such a disaster recovery maturity model requires that the organization understand dependencies among various entities and data objects. Recovery usually requires restoring the data and bringing back critical systems in a specific incremental manner, Implementation Based on the business needs, understanding dependency and its relationship can be somewhere in the middle levels of the maturity models. In a 4-level system, it is most likely in Level 2 or Level 3. The other approach is to split the Dependency Management into the same number of milestones as the number of levels. Suppose we are using a 4-level maturity model. In that case, we can split up dependency management to span all 4 Levels, starting with the most straightforward steps and going all the way to the most complicated, expensive, and involved steps. Going forward, we will only discuss the dependency management aspect of this maturity model. Level 1 - Discovering and Understanding Dependencies For many organizations, this can be the most daunting task. If dependency management was never considered necessary, there might be no institutional knowledge. We will start by discussing technical dependencies and then discuss process dependencies. Regarding technical dependencies, we need to identify the direct dependencies first. If the code is written in JavaScript and runs on a cloud service, then the direct dependencies might be JavaScript, NodeJS, AWS Lambda, etc. If we use npm for package management, the packages listed in the dependency file are direct dependencies. Next, we have transitive dependencies, which are pulled automatically from direct dependencies. In practice, this forms a directed acyclic graph. Another aspect of technical dependencies is the cloud architecture. Let’s take an example of AWS—we might use EC2, S3, API Gateway, CloudFront, ELB, etc. If the cloud resources were deployed using tools like CloudFormation or CDK, then it would be trivial to determine the dependencies. If the resources were created manually, the dependency diagram must be made manually by reading the source code and drawing conclusions. Process dependency falls under the non-technical category and defines how different stakeholders work together to move forward. It can also outline the release process or runbooks to invoke during an incident. Level 2 - Setup Continuous Dependencies Validation Dependencies can change since there are too many cooks in the kitchen. The organization's continuous integration tool should enumerate and track the direct code and library dependencies. Every time the code is pushed, a snapshot of current pinned dependencies should be saved to recreate the specific circumstances or restore to a known good state. Like the Continuous integration concept, the non-technical aspects should have some automation. Alerts should be created on metric, and using tools like PagerDuty, appropriate people should be notified of issues, and proper escalation channels should be created. It should be tested occasionally to avoid the known problem called Dogs Not Barking - a situation when you wonder if you are not getting any alerts because nothing is wrong or the alerting logic is broken. Some dependencies can be validated by using the Scream test. Under proper notification and preparation, turn off specific dependencies and see what fails. You may find a Load Bearing Mac Mini. Collect all of this configuration and manage it through some kind of provisioning tool like Chef and Terraform Level 3 - Fixing dependencies by adding, updating, or removing Once we have all the dependencies figured out, take some time and pat yourself on the back. Now, back on the issue, the work isn’t done. During the quest, you realize that some dependencies are causing more problems than they solve. One approach would be to update the dependencies. For example, if we are using old versions of OpenSSL, updating them to newer versions can solve many of the warnings raised by the build system and even help us pass any security compliance. Sometimes, the specific versions of two separate packages are incompatible. The solution is to find versions that can work together. This involves changing the version and might involve downgrading one or more packages. Sometimes, just removing a package or dependency solves the problem. It could have been a dead dependency with no further need but causing warnings and spamming the application logs. Under some circumstances, we might have to add a dependency to bring harmony. Suppose a transitive dependency is causing the problem, but we cannot update the direct dependency. In that case, explicitly adding the fixed version of the transitive dependency as a direct dependency can be an acceptable solution. Level 4 - Manual and Automated Disaster Recovery Drills This is the highest form of maturity in disaster recovery. We need runbooks that outline the roles and responsibilities of individuals involved. The runbook should also define the interdependencies and criticality of each step. The disaster recovery process should be practiced regularly by simulating a disaster and identifying possible sources of friction that get introduced when the plan is set in motion. The gold standard should be automated disaster recovery under human supervision. Automating the disaster recovery workflow ensures that humans do not make mistakes that go unnoticed. Automating has an additional advantage in that we can now run stress tests and simulation disasters by turning off certain network parts in a controlled manner to validate whether our automated disaster recovery is performing as expected. Conclusion Dependency management plays a critical role in disaster recovery, which is essential after a security incident. By following a structured and methodological approach, organizations can build their understanding progressively and control the dependencies. Each maturity model level builds on the previous one and strengthens the organization's security posture. While it can be easy to write off dependency management as a superfluous technical exercise, it is primarily about creating a comprehensive framework that brings together computer systems, people, and processes to work harmoniously. The systematic approach ensures that when disaster strikes, even in the form of a security breach, we can safely recover the data and be confident in the integrity of the said data. The world is a much more connected place than it was 20 years ago. With the change came new expectations. Downtimes can cripple businesses. There is an expectation of privacy and security. If we post on Facebook and the post gets lost due to any kind of issue, people will not tolerate it. Data integrity and durability are more critical than ever. As an organization, we must consider multiple technological tenets—security, availability, latency, durability, integrity, reliability, and privacy. We don’t get to choose from this list; we just sort it by importance based on business needs. Business continuity Disaster can come in many flavors, ranging from natural disasters to hardware failures, misconfiguration, and cyberattacks. The problem with cyberattacks is that we risk having our data stolen and wonder if the rest of the data is trustworthy. Maybe the attack was a sleight of hand, and the primary objective was to introduce malicious data that would haunt the organization forever. After the security incident, we need to recover the data and restore the service to the level our customers expect. One of the issues we face is reconstructing the original picture and configuration. We need to understand how all the pieces work together and their interdependency. Data restoration is more than just restoring a highly scalable web service snapshot. Objective At this point, our primary objective should be to ensure that our services are available and reliable by whatever means necessary. In the context of dependency management, we need to have a comprehensive data and dependency catalog, including the relationships between the entities. This provides us with the necessary insight into what exists. We also need regular operations testing and robust disaster recovery through automation and manual runbooks. We need to cultivate a culture of disaster recovery fire drills and identify fallbacks. Maturity Model Like an individual who enters college goes through freshman, sophomore, junior, and senior years before graduating, businesses need to follow a slow, progressive approach. It’s impractical for a company or organization to go from no disaster recovery to a fully-fledged, perfectly fleshed-out plan. The road to success is incremental, and each step builds on the previous step. Maturity models examine an organization’s current state from any specific perspective, such as disaster recovery, and help the organization reach the desired state or capability. As the organization progresses toward the end goal, it goes through various checkpoints, usually called Levels. Most Maturity Models have four levels, starting from Level 1 up to Level 4. Why are we talking about maturity models? One step in such a disaster recovery maturity model requires that the organization understand dependencies among various entities and data objects. Recovery usually requires restoring the data and bringing back critical systems in a specific incremental manner, Implementation Based on the business needs, understanding dependency and its relationship can be somewhere in the middle levels of the maturity models. In a 4-level system, it is most likely in Level 2 or Level 3. The other approach is to split the Dependency Management into the same number of milestones as the number of levels. Suppose we are using a 4-level maturity model. In that case, we can split up dependency management to span all 4 Levels, starting with the most straightforward steps and going all the way to the most complicated, expensive, and involved steps. Going forward, we will only discuss the dependency management aspect of this maturity model. Level 1 - Discovering and Understanding Dependencies For many organizations, this can be the most daunting task. If dependency management was never considered necessary, there might be no institutional knowledge. We will start by discussing technical dependencies and then discuss process dependencies. Regarding technical dependencies, we need to identify the direct dependencies first. If the code is written in JavaScript and runs on a cloud service, then the direct dependencies might be JavaScript, NodeJS, AWS Lambda, etc. If we use npm for package management, the packages listed in the dependency file are direct dependencies. Next, we have transitive dependencies, which are pulled automatically from direct dependencies. In practice, this forms a directed acyclic graph. Another aspect of technical dependencies is the cloud architecture. Let’s take an example of AWS—we might use EC2, S3, API Gateway, CloudFront, ELB, etc. If the cloud resources were deployed using tools like CloudFormation or CDK, then it would be trivial to determine the dependencies. If the resources were created manually, the dependency diagram must be made manually by reading the source code and drawing conclusions. Process dependency falls under the non-technical category and defines how different stakeholders work together to move forward. It can also outline the release process or runbooks to invoke during an incident. Level 2 - Setup Continuous Dependencies Validation Dependencies can change since there are too many cooks in the kitchen. The organization's continuous integration tool should enumerate and track the direct code and library dependencies. Every time the code is pushed, a snapshot of current pinned dependencies should be saved to recreate the specific circumstances or restore to a known good state. Like the Continuous integration concept, the non-technical aspects should have some automation. Alerts should be created on metric, and using tools like PagerDuty, appropriate people should be notified of issues, and proper escalation channels should be created. It should be tested occasionally to avoid the known problem called Dogs Not Barking - a situation when you wonder if you are not getting any alerts because nothing is wrong or the alerting logic is broken. Some dependencies can be validated by using the Scream test . Under proper notification and preparation, turn off specific dependencies and see what fails. You may find a Load Bearing Mac Mini . Collect all of this configuration and manage it through some kind of provisioning tool like Chef and Terraform Scream test Scream test Load Bearing Mac Mini Load Bearing Mac Mini Level 3 - Fixing dependencies by adding, updating, or removing Once we have all the dependencies figured out, take some time and pat yourself on the back. Now, back on the issue, the work isn’t done. During the quest, you realize that some dependencies are causing more problems than they solve. One approach would be to update the dependencies. For example, if we are using old versions of OpenSSL, updating them to newer versions can solve many of the warnings raised by the build system and even help us pass any security compliance. Sometimes, the specific versions of two separate packages are incompatible. The solution is to find versions that can work together. This involves changing the version and might involve downgrading one or more packages. Sometimes, just removing a package or dependency solves the problem. It could have been a dead dependency with no further need but causing warnings and spamming the application logs. Under some circumstances, we might have to add a dependency to bring harmony. Suppose a transitive dependency is causing the problem, but we cannot update the direct dependency. In that case, explicitly adding the fixed version of the transitive dependency as a direct dependency can be an acceptable solution. Level 4 - Manual and Automated Disaster Recovery Drills This is the highest form of maturity in disaster recovery. We need runbooks that outline the roles and responsibilities of individuals involved. The runbook should also define the interdependencies and criticality of each step. The disaster recovery process should be practiced regularly by simulating a disaster and identifying possible sources of friction that get introduced when the plan is set in motion. The gold standard should be automated disaster recovery under human supervision. Automating the disaster recovery workflow ensures that humans do not make mistakes that go unnoticed. Automating has an additional advantage in that we can now run stress tests and simulation disasters by turning off certain network parts in a controlled manner to validate whether our automated disaster recovery is performing as expected. Conclusion Dependency management plays a critical role in disaster recovery, which is essential after a security incident. By following a structured and methodological approach, organizations can build their understanding progressively and control the dependencies. Each maturity model level builds on the previous one and strengthens the organization's security posture. While it can be easy to write off dependency management as a superfluous technical exercise, it is primarily about creating a comprehensive framework that brings together computer systems, people, and processes to work harmoniously. The systematic approach ensures that when disaster strikes, even in the form of a security breach, we can safely recover the data and be confident in the integrity of the said data.

Dependency Management is Critical for Disaster Recovery After a Security Incident

Samsung, the world's second largest technology company by revenue, recently unveiled its plan to build the first AI-powered home appliances to have blockchain security-grade architecture. In other words, the tech giant is planning to leverage its Knox Matrix security framework  to create a ‘Trust Chain”, in a bid to secure connected devices in smart homes. This, like many other instances, is clear proof of the growing intersection between AI and blockchain technology,  which is often marked by the pronounced interest of tech companies in blockchain solutions. It reinforces the theory that AI needs blockchain and vice versa.  (Put simply, intelligence needs trust to thrive). In the words of Peter Kyle, UK’s Secretary of State For Science And Technology: AI has the potential to improve our public services, boost productivity and rebuild our economy.  But to take full advantage,  we need to build trust in these systems. Moreover, AI needs not just trust but it also needs decentralization to thrive. With decentralized AI, we can securely and efficiently distribute AI data against the background of centralized rules, thus enabling us to break free from centralized AI platforms commonly referred to as ‘AI data silos”. Dismantling AI Ecosystem's Bottlenecks AI must be built on trust and decentralization. The reasons are straightforward. In traditional AI systems, large corporations wield significant control over the distribution and accessibility of AI data. This centralized control is a bottleneck to AI development because it practically limits the potential of AI systems to learn from a diverse range of comprehensive datasets, thus hindering innovation in various industries where AI is used. Additionally, the lack of user control over their sensitive data has brought the issue of users’ privacy to the fore, making it one of their core underlying issues in AI development. Given the tendency of giant tech companies to cross the line by breaching users' privacy, the need for a collaborative AI ecosystem built on users’ privacy and ownership has become more apparent than ever. Furthermore, the centralized storage of AI data also poses a significant challenge to its accessibility. A decentralized AI data storage, however, opens up access to multiple stakeholders working in the AI industry,  improving the quality of AI data and the sophistication of its end users. A general example of the collaborative approach to data storage and accessibility is DePIN platforms which allow users to rent out their computing resources in return for tokenized rewards. These platforms incentivize users to individually participate in the distribution and cloud storage of heavy data loads on a decentralized network. Filecoin, Storj, Airweave, and Zetta AI, for example, reward users for contributing to a decentralized data economy, enabling the coordination of a global network of contributors—from developers to enterprises—to build, share, and be fairly rewarded for high-quality AI asset contributions while maintaining ownership, privacy, and control. Benefits of Decentralized AI Decentralized AI offers numerous advantages when compared to traditional data storage systems, which are often criticized for their centralization, limited accessibility, and breach of users’ privacy. Some of these benefits include : Data Quality As Jeff Dean rightly put it: The quality of your data determines the quality of your AI. Enabling AI models to learn from a wider comprehensive dataset can significantly improve the quality and output of AI data, thus creating more sophisticated AI data repositories for various stakeholders in the industry. Decentralized Ownership The beauty of decentralized AI is its ability to foster decentralized ownership of data while preserving users’ privacy and security. Centralization is a far cry from these attributes because it allows few platforms with significant resources to determine how AI data is stored and used. Collaboration and Incentive Decentralized AI fosters open collaboration among the various participants in a decentralized network by rewarding collaborative data sharing and participants’ contributions to AI model development. Tokenized rewards (i.e. tokens) are fairly distributed to users as incentives. Increased Transparency and Trust Decentralized AI fosters transparency, which involves recording all transactions and decision-making processes on a blockchain. Blockchain has the ability to ensure that AI data is traced and verified.  The traceability and transparency of AI data is crucial in building trust with users as it enables them to understand how their data is used.  This is a stark contrast to centralized platforms where users have little or no knowledge of how their data are used. Democratized AI development Famous AI advocate, Cathy O Neil, once said: Decentralized AI is a powerful tool for democratizing access to AI technology. By breaking down the barriers of centralization, we can empower individuals and communities to develop and deploy AI solutions that address their specific needs. The development of AI is dependent on the diversity of its learning models. It's vital to train AI systems from multiple rather than a single data set to enhance their performance and the quality of data across various industries. Latest Development: ZettaBlock Unveils KiteAI To Democratize AI Development ZettaBlock recently unveiled KiteAI, a transformative AI platform that opens access to non-public data for AI developers, with a focus on ensuring that contributors are fairly compensated. The team has concentrated on building enhanced data pipelines, especially for blockchain data, supporting key players like SUI, Eigenlayer, Chainlink Labs,etc. This platform has processed tens of terabytes of data, making it accessible to organizations for AI model development while safeguarding the privacy of the original data sources. Through advanced data attribution and privacy-preserving technology, ZettaBlock’s platform uniquely supports a collaborative economy. It ensures that contributors are recognized and rewarded as their data directly contributes to model performance and value. ZettaBlock is set to showcase elements of this technology at the upcoming Devcon, where attendees will gain insights into how the platform enables secure, equitable access to data for AI advancements. Conclusion: Building a responsible, efficient, and inclusive AI ecosystem is at the heart of decentralized AI. Moreso, it is a paradigm shift from centralized control of vital AI data hindering the further development of AI models. By encouraging decentralized data sharing and storage, it increases accessibility and foresters a collaborative approach to improving the quality of AI data. Most importantly, decentralized AI is poised to help AI to unlock its full potential and serve the various needs of individuals and organizations. Samsung, the world's second largest technology company by revenue, recently unveiled its plan to build the first AI-powered home appliances to have blockchain security-grade architecture. In other words, the tech giant is planning to leverage its Knox Matrix security framework  to create a ‘Trust Chain”, in a bid to secure connected devices in smart homes. This, like many other instances, is clear proof of the growing intersection between AI and blockchain technology,  which is often marked by the pronounced interest of tech companies in blockchain solutions. It reinforces the theory that AI needs blockchain and vice versa.  (Put simply, intelligence needs trust to thrive). In the words of Peter Kyle, UK’s Secretary of State For Science And Technology: AI has the potential to improve our public services, boost productivity and rebuild our economy.  But to take full advantage,  we need to build trust in these systems. AI has the potential to improve our public services, boost productivity and rebuild our economy.  But to take full advantage,  we need to build trust in these systems. Moreover, AI needs not just trust but it also needs decentralization to thrive. With decentralized AI, we can securely and efficiently distribute AI data against the background of centralized rules, thus enabling us to break free from centralized AI platforms commonly referred to as ‘AI data silos”. Dismantling AI Ecosystem's Bottlenecks AI must be built on trust and decentralization. The reasons are straightforward. In traditional AI systems, large corporations wield significant control over the distribution and accessibility of AI data. This centralized control is a bottleneck to AI development because it practically limits the potential of AI systems to learn from a diverse range of comprehensive datasets, thus hindering innovation in various industries where AI is used. This centralized control is a bottleneck to AI development because it practically limits the potential of AI systems to learn from a diverse range of comprehensive datasets, thus hindering innovation in various industries where AI is used. This centralized control is a bottleneck to AI development because it practically limits the potential of AI systems to learn from a diverse range of comprehensive datasets, thus hindering innovation in various industries where AI is used. Additionally, the lack of user control over their sensitive data has brought the issue of users’ privacy to the fore, making it one of their core underlying issues in AI development. Given the tendency of giant tech companies to cross the line by breaching users' privacy, the need for a collaborative AI ecosystem built on users’ privacy and ownership has become more apparent than ever. Furthermore, the centralized storage of AI data also poses a significant challenge to its accessibility. A decentralized AI data storage, however, opens up access to multiple stakeholders working in the AI industry,  improving the quality of AI data and the sophistication of its end users. A general example of the collaborative approach to data storage and accessibility is DePIN platforms which allow users to rent out their computing resources in return for tokenized rewards. These platforms incentivize users to individually participate in the distribution and cloud storage of heavy data loads on a decentralized network. Filecoin, Storj, Airweave, and Zetta AI, for example, reward users for contributing to a decentralized data economy, enabling the coordination of a global network of contributors—from developers to enterprises—to build, share, and be fairly rewarded for high-quality AI asset contributions while maintaining ownership, privacy, and control. Benefits of Decentralized AI Decentralized AI offers numerous advantages when compared to traditional data storage systems, which are often criticized for their centralization, limited accessibility, and breach of users’ privacy. Some of these benefits include : Data Quality As Jeff Dean rightly put it: The quality of your data determines the quality of your AI. The quality of your data determines the quality of your AI. Enabling AI models to learn from a wider comprehensive dataset can significantly improve the quality and output of AI data, thus creating more sophisticated AI data repositories for various stakeholders in the industry. Decentralized Ownership The beauty of decentralized AI is its ability to foster decentralized ownership of data while preserving users’ privacy and security. Centralization is a far cry from these attributes because it allows few platforms with significant resources to determine how AI data is stored and used. Collaboration and Incentive Decentralized AI fosters open collaboration among the various participants in a decentralized network by rewarding collaborative data sharing and participants’ contributions to AI model development. Tokenized rewards (i.e. tokens) are fairly distributed to users as incentives. Increased Transparency and Trust Decentralized AI fosters transparency, which involves recording all transactions and decision-making processes on a blockchain. Blockchain has the ability to ensure that AI data is traced and verified.  The traceability and transparency of AI data is crucial in building trust with users as it enables them to understand how their data is used.  This is a stark contrast to centralized platforms where users have little or no knowledge of how their data are used. Democratized AI development Famous AI advocate, Cathy O Neil, once said: Decentralized AI is a powerful tool for democratizing access to AI technology. By breaking down the barriers of centralization, we can empower individuals and communities to develop and deploy AI solutions that address their specific needs. Decentralized AI is a powerful tool for democratizing access to AI technology. By breaking down the barriers of centralization, we can empower individuals and communities to develop and deploy AI solutions that address their specific needs. The development of AI is dependent on the diversity of its learning models. It's vital to train AI systems from multiple rather than a single data set to enhance their performance and the quality of data across various industries. Latest Development: ZettaBlock Unveils KiteAI To Democratize AI Development Latest Development: ZettaBlock Unveils KiteAI To Democratize AI Development ZettaBlock recently unveiled KiteAI, a transformative AI platform that opens access to non-public data for AI developers, with a focus on ensuring that contributors are fairly compensated. The team has concentrated on building enhanced data pipelines, especially for blockchain data, supporting key players like SUI, Eigenlayer, Chainlink Labs,etc. This platform has processed tens of terabytes of data, making it accessible to organizations for AI model development while safeguarding the privacy of the original data sources. Through advanced data attribution and privacy-preserving technology, ZettaBlock’s platform uniquely supports a collaborative economy. It ensures that contributors are recognized and rewarded as their data directly contributes to model performance and value. ZettaBlock is set to showcase elements of this technology at the upcoming Devcon, where attendees will gain insights into how the platform enables secure, equitable access to data for AI advancements. Conclusion: Conclusion: Building a responsible, efficient, and inclusive AI ecosystem is at the heart of decentralized AI. Moreso, it is a paradigm shift from centralized control of vital AI data hindering the further development of AI models. By encouraging decentralized data sharing and storage, it increases accessibility and foresters a collaborative approach to improving the quality of AI data. Most importantly, decentralized AI is poised to help AI to unlock its full potential and serve the various needs of individuals and organizations.

AI Needs Two Things To Thrive: Trust And Decentralization

Edit: Previously I wrote about the "6 Most Popular Vue.js UI Libraries (Vue 3) in 2023". As we are now in 2024, I have revisited the different libraries and updated them for the current year 🎉 Vue.js, a JavaScript framework, has been gaining a lot of attention in recent years due to its simplicity, flexibility, and performance. Also, User Interface (UI) component libraries have become an essential aspect of web development, providing a fast and convenient way to build beautiful and responsive user interfaces. Vue 3 has become the default choice to build modern applications since Vue 2 reached its end of life on December 31, 2023. The need for UI component libraries designed specifically for Vue 3 has risen. In this article, we will take a look at the six most popular Vue.js UI component libraries for 2024, categorized based on their popularity within English and Chinese-speaking communities. I decided to categorize this way because of the massive popularity of Vue.js in China according to an interview with Evan You, the creator of Vue.js, who was born in China and grew up in a city near Shanghai. Moreover, Vue has well-written documents in Chinese. As teams from big companies in China such as Alibaba, Tencent, and Baidu started using Vue.js, all these factors may have contributed to its popularity in the country. Vue-PDF-Viewer: Flexible and Powerful Vue.js PDF Component Just a quick background about what I’m working on. Vue-PDF-Viewer renders the PDF viewer on your Vue or Nuxt websites so that your users can interact with your PDF document without leaving your sites. The component has over 20 features including theme customization, built-in localization, web responsiveness, and more. I would be grateful if you could check Vue-PDF-Viewer out. It will encourage me to make even more content. ❤️‍🔥 English Focused Community 1. Vuetify Vuetify is a popular Vue.js UI component library based on Material Design specifications. It provides over 100 customizable components for creating beautiful and responsive user interfaces. With its modular design, developers can selectively import components, which keeps the bundle size small and improves performance. Additionally, Vuetify integrates seamlessly with Nuxt 3 and features powerful theming capabilities where developers can customize their application style and match it with their brand. As of February 2024, Vuetify has over 38,800 stars (from 37,900 stars in 2023) on GitHub and an average weekly download count of close to 500,000. (The trend line seems to be growing steadily over the years) Learn more at https://vuetifyjs.com Remark: There are still a couple of Vuetify 2 components including calendar, overflow-btn, speed-dial, time-picker, and treeview that are not yet available in Vuetify 3. According to the official Vuetify guide, they will be released by Vuetify Labs when development is completed. 2. Quasar Quasar's UI Components feature 70 high-performance customizable Material Design components and icons of various styles (bootstrap, material, fontawesome, and many more). The documentation is detailed and well thought-out. The library also has pre-built features including animations and functions to handle dates and times. What makes Quasar, founded in 2015, different and stand out from other UI component libraries is that Quasar is not only a UI component library but a dynamic Vue framework. You can develop Vue.js desktop, web, and mobile applications with a single codebase. As the saying goes, write once and use it everywhere. As of February 2024, Quasar has over 25,000 stars (from 24,200 stars in 2023) on GitHub and an average weekly download count of over 100,000. Learn more on https://quasar.dev/ 3. PrimeVue PrimeVue is a sleek Vue.js component library that offers over 90 components and 200+ icons making it one of the most comprehensive libraries in the Vue.js community. It's a lightweight library with exclusive Tailwind CSS integration, enabling developers to build complex enterprise-level applications with ease. PrimeVue is powered by PrimeTek, which serves millions of developers of Fortune 500 companies such as Intel, Nvidia, and American Express, lending it massive credibility in the enterprise space. PrimeVue also features an intuitive API, allowing developers to quickly customize the components to achieve their desired designs. As of February 2024, PrimeVue has over 6,800 stars (from 4,300 stars in 2023) on GitHub and an average weekly download count of over 170,000 (A huge increase from around 100,000 downloads in September 2023). Learn more on https://primevue.org/ Chinese Focused Community 1. Element Plus Element Plus is a community-developed project born from Element UI which supports only Vue 2.X. Due to its predecessor's popularity, it has naturally gained a lot of attention from developers, especially those in China. A TypeScript-based library with a complete type definition, Element Plus is not based on Material Design and has its own distinct UI style which can modified quite easily. Element Plus simplifies component utilization, making the code more maintainable and readable with Vue 3's Composition API. As of February 2024, Element Plus has over 22,600 stars (from 21,300 stars in 2023) on GitHub and an average weekly download count of over 200,000. Learn more at https://element-plus.org/en-US/ 2. Ant Design Vue Ant Design Vue (Antdv) is a popular TypeScript-based UI component library based on Ant Design, a library that was developed for React and was originally created by a team from Alibaba. But it has gained traction in the Vue.js community for its ease of use and its rich feature set. It offers a comprehensive range of components like tree structures, forms, and data visualization components. Similar to Element Plus, Antdv has its own unique UI style. Although it may initially seem daunting to explore its huge sets of UI components and features, once you get the hang of it, Antdv can be a very powerful UI component library for projects of all sizes. As of February 2024, Ant Design Vue has over 19,300 stars (from 18,600 stars in 2023) on GitHub and an average weekly download count of over 80,000. Learn more on https://antdv.com/ 3. Naive UI Naive UI is a TypeScript-based UI component library developed by TuSimple, a Chinese autonomous truck company based in California. It was mentioned by Evan You, the creator of Vue.js, in his Weibo blog back in 2021. Naive UI consists of over 90 components that can be imported to use in your project. Most impressively, all 90+ components can be treeshaken. This means that the component can be imported individually into your application without waste. Documentation of Naive UI is also well-documented and easy to follow. As of February 2024, Naive UI has over 14,800 stars on GitHub and an average weekly download count of over 30,000. Learn more at https://github.com/tusen-ai/naive-ui Special Mention: Nut UI Nut UI is a mobile UI component library that is developed by the Chinese e-commerce giant, JD.com (also known as Jingdong). It provides a JD-style mobile UI component library that is used by JD in production. Nut UI features high-quality UI components that are well-tested (unit test coverage more than 80%). It has clear documentation and supports TypeScript. Furthermore, it provides Sketch design resources for designers to easily create design screens. As of February 2024, Nut UI has over 5,700 stars on GitHub and an average weekly download count of over 3,000. Learn more at https://github.com/jdf2e/nutui/blob/v4/README_EN.md Conclusion In conclusion, Vue.js has gained popularity due to its flexibility, simplicity, and performance. The availability of different UI component libraries has made it easier for developers to build complex and elegant applications at speed with ease. Whether you're building large complex applications or small, highly performant ones, there is always the right Vue.js UI component library suitable for your needs. Vue-PDF-Viewer: Flexible and Powerful Vue.js PDF Component If you feel like this article helped you, please check out Vue-PDF-Viewer. You can customize the PDF viewer component to your theme, add locales, configure panels, and more. Each function has TS and JS codes, unit tests, and interactive demos. With our starter kits, you can start rendering the Vue-PDF-Viewer in minutes. It would encourage me to continue creating even more content. Thank you in advance! 🙏 Edit: Previously I wrote about the "6 Most Popular Vue.js UI Libraries (Vue 3) in 2023". As we are now in 2024, I have revisited the different libraries and updated them for the current year 🎉 Edit: Previously I wrote about the " 6 Most Popular Vue.js UI Libraries (Vue 3) in 2023 ". As we are now in 2024, I have revisited the different libraries and updated them for the current year 🎉 6 Most Popular Vue.js UI Libraries (Vue 3) in 2023 Vue.js, a JavaScript framework, has been gaining a lot of attention in recent years due to its simplicity, flexibility, and performance. Also, User Interface (UI) component libraries have become an essential aspect of web development, providing a fast and convenient way to build beautiful and responsive user interfaces. Vue 3 has become the default choice to build modern applications since Vue 2 reached its end of life on December 31, 2023. The need for UI component libraries designed specifically for Vue 3 has risen. In this article, we will take a look at the six most popular Vue.js UI component libraries for 2024, categorized based on their popularity within English and Chinese-speaking communities. I decided to categorize this way because of the massive popularity of Vue.js in China according to an interview with Evan You, the creator of Vue.js, who was born in China and grew up in a city near Shanghai. an interview Moreover, Vue has well-written documents in Chinese. As teams from big companies in China such as Alibaba, Tencent, and Baidu started using Vue.js, all these factors may have contributed to its popularity in the country. Vue-PDF-Viewer: Flexible and Powerful Vue.js PDF Component Just a quick background about what I’m working on. Vue-PDF-Viewer renders the PDF viewer on your Vue or Nuxt websites so that your users can interact with your PDF document without leaving your sites. The component has over 20 features including theme customization, built-in localization, web responsiveness, and more. Vue-PDF-Viewer I would be grateful if you could check Vue-PDF-Viewer out. It will encourage me to make even more content. ❤️‍🔥 Vue-PDF-Viewer English Focused Community 1. Vuetify Vuetify is a popular Vue.js UI component library based on Material Design specifications. It provides over 100 customizable components for creating beautiful and responsive user interfaces. With its modular design, developers can selectively import components, which keeps the bundle size small and improves performance. Additionally, Vuetify integrates seamlessly with Nuxt 3 and features powerful theming capabilities where developers can customize their application style and match it with their brand. As of February 2024, Vuetify has over 38,800 stars (from 37,900 stars in 2023) on GitHub and an average weekly download count of close to 500,000. (The trend line seems to be growing steadily over the years) trend line Learn more at https://vuetifyjs.com https://vuetifyjs.com Remark: There are still a couple of Vuetify 2 components including calendar, overflow-btn, speed-dial, time-picker, and treeview that are not yet available in Vuetify 3. According to the official Vuetify guide, they will be released by Vuetify Labs when development is completed. Remark: There are still a couple of Vuetify 2 components including calendar, overflow-btn, speed-dial, time-picker, and treeview that are not yet available in Vuetify 3. According to the official Vuetify guide, they will be released by Vuetify Labs when development is completed. 2. Quasar Quasar's UI Components feature 70 high-performance customizable Material Design components and icons of various styles (bootstrap, material, fontawesome, and many more). The documentation is detailed and well thought-out. The library also has pre-built features including animations and functions to handle dates and times. What makes Quasar, founded in 2015, different and stand out from other UI component libraries is that Quasar is not only a UI component library but a dynamic Vue framework. You can develop Vue.js desktop, web, and mobile applications with a single codebase. As the saying goes, write once and use it everywhere. As of February 2024, Quasar has over 25,000 stars (from 24,200 stars in 2023) on GitHub and an average weekly download count of over 100,000. Learn more on https://quasar.dev/ https://quasar.dev/ 3. PrimeVue PrimeVue is a sleek Vue.js component library that offers over 90 components and 200+ icons making it one of the most comprehensive libraries in the Vue.js community. It's a lightweight library with exclusive Tailwind CSS integration, enabling developers to build complex enterprise-level applications with ease. PrimeVue is powered by PrimeTek, which serves millions of developers of Fortune 500 companies such as Intel, Nvidia, and American Express, lending it massive credibility in the enterprise space. PrimeVue also features an intuitive API, allowing developers to quickly customize the components to achieve their desired designs. As of February 2024, PrimeVue has over 6,800 stars (from 4,300 stars in 2023) on GitHub and an average weekly download count of over 170,000 ( A huge increase from around 100,000 downloads in September 2023). A huge increase Learn more on https://primevue.org/ https://primevue.org/ Chinese Focused Community 1. Element Plus Element Plus is a community-developed project born from Element UI which supports only Vue 2.X. Due to its predecessor's popularity, it has naturally gained a lot of attention from developers, especially those in China. A TypeScript-based library with a complete type definition, Element Plus is not based on Material Design and has its own distinct UI style which can modified quite easily. Element Plus simplifies component utilization, making the code more maintainable and readable with Vue 3's Composition API. As of February 2024, Element Plus has over 22,600 stars (from 21,300 stars in 2023) on GitHub and an average weekly download count of over 200,000. Learn more at https://element-plus.org/en-US/ https://element-plus.org/en-US/ 2. Ant Design Vue Ant Design Vue (Antdv) is a popular TypeScript-based UI component library based on Ant Design, a library that was developed for React and was originally created by a team from Alibaba. But it has gained traction in the Vue.js community for its ease of use and its rich feature set. It offers a comprehensive range of components like tree structures, forms, and data visualization components. Similar to Element Plus, Antdv has its own unique UI style. Although it may initially seem daunting to explore its huge sets of UI components and features, once you get the hang of it, Antdv can be a very powerful UI component library for projects of all sizes. As of February 2024, Ant Design Vue has over 19,300 stars (from 18,600 stars in 2023) on GitHub and an average weekly download count of over 80,000. Learn more on https://antdv.com/ https://antdv.com/ 3. Naive UI Naive UI is a TypeScript-based UI component library developed by TuSimple, a Chinese autonomous truck company based in California. It was mentioned by Evan You, the creator of Vue.js, in his Weibo blog back in 2021. Naive UI consists of over 90 components that can be imported to use in your project. Most impressively, all 90+ components can be treeshaken . This means that the component can be imported individually into your application without waste. Documentation of Naive UI is also well-documented and easy to follow. treeshaken As of February 2024, Naive UI has over 14,800 stars on GitHub and an average weekly download count of over 30,000. Learn more at https://github.com/tusen-ai/naive-ui https://github.com/tusen-ai/naive-ui Special Mention: Nut UI Nut UI is a mobile UI component library that is developed by the Chinese e-commerce giant, JD.com (also known as Jingdong). It provides a JD-style mobile UI component library that is used by JD in production. JD.com Nut UI features high-quality UI components that are well-tested (unit test coverage more than 80%). It has clear documentation and supports TypeScript. Furthermore, it provides Sketch design resources for designers to easily create design screens. As of February 2024, Nut UI has over 5,700 stars on GitHub and an average weekly download count of over 3,000. Learn more at https://github.com/jdf2e/nutui/blob/v4/README_EN.md https://github.com/jdf2e/nutui/blob/v4/README_EN.md Conclusion In conclusion, Vue.js has gained popularity due to its flexibility, simplicity, and performance. The availability of different UI component libraries has made it easier for developers to build complex and elegant applications at speed with ease. Whether you're building large complex applications or small, highly performant ones, there is always the right Vue.js UI component library suitable for your needs. Vue-PDF-Viewer: Flexible and Powerful Vue.js PDF Component If you feel like this article helped you, please check out Vue-PDF-Viewer . You can customize the PDF viewer component to your theme, add locales, configure panels, and more. Each function has TS and JS codes, unit tests, and interactive demos. With our starter kits, you can start rendering the Vue-PDF-Viewer in minutes. Vue-PDF-Viewer Vue-PDF-Viewer It would encourage me to continue creating even more content. Thank you in advance! 🙏

⚡️ 6 Vue.js UI Libraries (Vue 3) That Are Trending in 2024 🔥

I've written several articles here on HackerNoon about the concept of Karma. I’ve always thought of Karma as a type of currency, deriving it from the functioning of monetary systems. A few days ago, I applied for the World Grant program, and while filling out the forms, I was reminded of an approach that I will present in more detail in this article. The Gamification of Helping Others Gamification is a very powerful motivating force. Many people run kilometers or learn a language just to earn a few digital badges. The idea almost suggests itself: what if we tried to gamify helping others? If we could encourage people, even just a little, to do good for others, it would make the world a much better place. The idea isn't entirely new. In 2009, Philip Rosedale (CTO of SecondLife) launched a startup called LoveMachine Inc., where, among other things, developers could 'send love' to each other. If someone wanted to express their gratitude to a colleague, they could send them love, which was like a badge that was publicly visible on the developer's profile. This was, of course, a very simple way of gamifying acts of kindness, but it was very inspiring to me at the time (the company has since shut down, so it’s only accessible via the Internet Archive). My other major inspiration is the protagonist of Charles Stross's novel Accelerando, Manfred Macx, who lived a prosperous life entirely without money, essentially based on favors. Is this really possible? Could one live without money, relying solely on mutual favors?" Economy of Favors In fact, the favor economy is the most natural form of economy. Doing favors is so fundamental that we don’t even consider it a business transaction, though that’s essentially what it is. When we do a favor for a friend, it’s perfectly reasonable to expect that in a similar situation, they would do the same for us. If favor-giving is always one-sided, we eventually feel taken advantage of, and the friendship often deteriorates. While this isn’t as precisely measurable as money, we subconsciously keep a 'cognitive ledger' of favors. About 2 million years ago, our ancestors lived in small communities and got along just fine without money. People would go hunting together, and if someone returned empty-handed from gathering, others would help them. In return, if someone else needed help, the community would support them. The economy of favors, therefore, works very well in small communities, but it has a significant limitation: it requires personal acquaintance. When the participants in a business transaction don’t know each other, or the transaction involves multiple people, the process becomes entirely untraceable, and the 'cognitive ledger' no longer works. This is why barter trade was established and, eventually, money. I have an entire article on the history of money. For those interested in a more detailed exploration of how money developed and what it really is, it might be worth a read. https://hackernoon.com/a-brief-history-of-money-from-the-economy-of-favors-to-bitcoin?embedable=true Karma: The Modernized Version of the Economy of Favors If we want to build an economy with a different dynamic, we need to return to the roots. In this sense, Bitcoin or other cryptocurrencies are not true alternatives to the current monetary system. They are speculative assets, much like national currencies, with the difference being that they aren’t issued by any one country. If we want to change the dynamics of the economy, we need to go further back in time to the concept of the economy of favors. As I mentioned earlier, the limitation of the economy of favors stems from the limitations of the 'cognitive ledger.' Favor transactions only work between people who know each other well personally. This is a significant limitation. If we could replace the 'cognitive ledger' with a global ledger, it would remove this barrier. Fortunately, we already have such a technology: the blockchain. By definition, the blockchain is a global ledger operated and owned by the community. It cannot be censored or tampered with. It is the perfect tool to extend the reach of the economy of favors from a small local community to the entire world. How does Karma work? Since I've already written a very detailed article on how Karma works from a technological perspective, here I’ll only provide a brief overview, highlighting the parts that are new to the concept. https://hackernoon.com/karma-an-erc20-compatible-alternative-money-on-the-ethereum-blockchain?embedable=true From a technological perspective, Karma is an ERC20 token, so it works with any Ethereum-compatible wallet. Sending Karma to anyone is as simple as sending any other ERC20 token. One major difference from other ERC20 tokens is that Karma never runs out. In this sense, it’s not like money; it’s more like love. Although Karma never runs out, it’s still not wise to spend it limitlessly, because all outgoing and incoming Karma transactions are public. This visibility shows how much kindness someone has offered to others and how much they’ve received in return. If someone has a lot of 'outgoing' Karma but little 'incoming' Karma, it means they’ve received more favors than they’ve given, which could negatively impact how others perceive them. Ideally, there should be a balance between 'incoming' and 'outgoing' Karma. The truly exciting feature of Karma is that transactions form a directed weighted graph, where cycles can emerge. Let’s say we pick up a hitchhiker (let's call him Tom) and give him a ride, for which he sends us Karma in gratitude. A few months later, Tom finds a lost kitten and, based on the tag on its collar, returns it to its owner, Alice, who gives Tom Karma as a thank-you. At her workplace, Alice helps her colleague John solve a problem, and John, in turn, gives her Karma in appreciation. Years later, we get a flat tire and don’t have a jack. Fortunately, another driver stops to help us—it's John. We send him Karma in gratitude, and the circle is complete. Imagine seeing in the app how the help we gave Tom years ago when we gave him a ride, eventually made its way back to us. This is where the name 'Karma' comes from. The philosophy of Karma, in short, is: do good things, and good things will happen to you. The Karma system visualizes this process and simultaneously incentivizes users to do good for others. Since Karma is not tied to the monetary system, it’s entirely up to us how much Karma we reward for a favor. As a general guideline, we might say that one hour of work is worth 100 Karma. However, if someone does us a big favor, we could give them 200 Karma for just 10 minutes of work, or if we feel it was a small favor, we could give only 50 Karma for an hour of work. It’s completely up to us how we value a fellow person’s favor. The basic requirement for the system to function is that each person can only have one profile, thus preventing Sybil attacks. If this condition is not met, anyone could create a new profile if their incoming and outgoing Karma balance is off, or use fake profiles to send Karma to themselves, misleading others. The perfect solution to this problem is WorldID, which provides a unique identifier linked to an iris, ensuring that each person can only have one WorldID. I’ve written a detailed article on how WorldID works. https://hackernoon.com/a-brief-introduction-of-worldcoin-proof-of-unique-humanness-on-blockchain?embedable=true Alongside WorldID, other elements of the World ecosystem provide an ideal foundation for Karma. WorldChain, World’s own Optimism-based L2 solution, is a perfect choice for running the system. On this chain, people with validated WorldIDs can execute transactions for free. The World App includes a built-in wallet necessary for ERC20 transactions, and the visual UI can be made accessible through a Mini App. So, is Karma money or not? One of the great lessons of the Bitcoin revolution, for me, is that money is whatever we consider it to be. If a group accepts something as money, then it is money. Money is nothing more than a social contract. In this sense, Karma can also function as money. Let’s look at an example of how Karma could replace money. If we want to get somewhere by car, we could call an Uber and pay the driver. However, we could also find someone who’s heading in the same direction and ask them to give us a ride in exchange for Karma. A whole 'favor-based Uber' service could be built on this idea. Similarly, a 'favor-based Airbnb' and other services are also conceivable. In small local communities, Karma could even fully replace money. Since all Karma transactions are permanently and publicly visible on each person’s profile, and everyone can only have one profile, Karma accounting becomes a very serious matter. We can think of it as a kind of credit system where the collateral is our unique profile and reputation. In some cases, this could even be a more substantial guarantee than a person’s wealth. Summary Although Karma can be derived from the monetary system, the goal has always been to create something better. Something that can’t be speculated on, accumulated, or increase social inequality. That’s what Karma is— a system that gamifies helping others and encourages people to do good for one another. If the concept proves even slightly workable and fulfills its promise, then it has been worth pursuing. Through Karma, perhaps the world can become a slightly better place... I've written several articles here on HackerNoon about the concept of Karma. I’ve always thought of Karma as a type of currency, deriving it from the functioning of monetary systems. A few days ago, I applied for the World Grant program , and while filling out the forms, I was reminded of an approach that I will present in more detail in this article. World Grant program The Gamification of Helping Others Gamification is a very powerful motivating force. Many people run kilometers or learn a language just to earn a few digital badges. The idea almost suggests itself: what if we tried to gamify helping others? If we could encourage people, even just a little, to do good for others, it would make the world a much better place. The idea isn't entirely new. In 2009, Philip Rosedale (CTO of SecondLife) launched a startup called LoveMachine Inc., where, among other things, developers could 'send love' to each other. If someone wanted to express their gratitude to a colleague, they could send them love, which was like a badge that was publicly visible on the developer's profile. This was, of course, a very simple way of gamifying acts of kindness, but it was very inspiring to me at the time (the company has since shut down, so it’s only accessible via the Internet Archive). My other major inspiration is the protagonist of Charles Stross's novel Accelerando , Manfred Macx, who lived a prosperous life entirely without money, essentially based on favors. Is this really possible? Could one live without money, relying solely on mutual favors?" Accelerando Accelerando Economy of Favors In fact, the favor economy is the most natural form of economy. Doing favors is so fundamental that we don’t even consider it a business transaction, though that’s essentially what it is. When we do a favor for a friend, it’s perfectly reasonable to expect that in a similar situation, they would do the same for us. If favor-giving is always one-sided, we eventually feel taken advantage of, and the friendship often deteriorates. While this isn’t as precisely measurable as money, we subconsciously keep a 'cognitive ledger' of favors. About 2 million years ago, our ancestors lived in small communities and got along just fine without money. People would go hunting together, and if someone returned empty-handed from gathering, others would help them. In return, if someone else needed help, the community would support them. The economy of favors, therefore, works very well in small communities, but it has a significant limitation: it requires personal acquaintance. When the participants in a business transaction don’t know each other, or the transaction involves multiple people, the process becomes entirely untraceable, and the 'cognitive ledger' no longer works. This is why barter trade was established and, eventually, money. I have an entire article on the history of money. For those interested in a more detailed exploration of how money developed and what it really is, it might be worth a read. https://hackernoon.com/a-brief-history-of-money-from-the-economy-of-favors-to-bitcoin?embedable=true https://hackernoon.com/a-brief-history-of-money-from-the-economy-of-favors-to-bitcoin?embedable=true Karma: The Modernized Version of the Economy of Favors If we want to build an economy with a different dynamic, we need to return to the roots. In this sense, Bitcoin or other cryptocurrencies are not true alternatives to the current monetary system. They are speculative assets, much like national currencies, with the difference being that they aren’t issued by any one country. If we want to change the dynamics of the economy, we need to go further back in time to the concept of the economy of favors. As I mentioned earlier, the limitation of the economy of favors stems from the limitations of the 'cognitive ledger.' Favor transactions only work between people who know each other well personally. This is a significant limitation. If we could replace the 'cognitive ledger' with a global ledger, it would remove this barrier. Fortunately, we already have such a technology: the blockchain. By definition, the blockchain is a global ledger operated and owned by the community. It cannot be censored or tampered with. It is the perfect tool to extend the reach of the economy of favors from a small local community to the entire world. How does Karma work? Since I've already written a very detailed article on how Karma works from a technological perspective, here I’ll only provide a brief overview, highlighting the parts that are new to the concept. https://hackernoon.com/karma-an-erc20-compatible-alternative-money-on-the-ethereum-blockchain?embedable=true https://hackernoon.com/karma-an-erc20-compatible-alternative-money-on-the-ethereum-blockchain?embedable=true From a technological perspective, Karma is an ERC20 token, so it works with any Ethereum-compatible wallet. Sending Karma to anyone is as simple as sending any other ERC20 token. ERC20 One major difference from other ERC20 tokens is that Karma never runs out. In this sense, it’s not like money; it’s more like love . it’s not like money; it’s more like love Although Karma never runs out, it’s still not wise to spend it limitlessly, because all outgoing and incoming Karma transactions are public. This visibility shows how much kindness someone has offered to others and how much they’ve received in return. If someone has a lot of 'outgoing' Karma but little 'incoming' Karma, it means they’ve received more favors than they’ve given, which could negatively impact how others perceive them. Ideally, there should be a balance between 'incoming' and 'outgoing' Karma. The truly exciting feature of Karma is that transactions form a directed weighted graph, where cycles can emerge. Let’s say we pick up a hitchhiker (let's call him Tom) and give him a ride, for which he sends us Karma in gratitude. A few months later, Tom finds a lost kitten and, based on the tag on its collar, returns it to its owner, Alice, who gives Tom Karma as a thank-you. At her workplace, Alice helps her colleague John solve a problem, and John, in turn, gives her Karma in appreciation. Years later, we get a flat tire and don’t have a jack. Fortunately, another driver stops to help us—it's John. We send him Karma in gratitude, and the circle is complete. Imagine seeing in the app how the help we gave Tom years ago when we gave him a ride, eventually made its way back to us. This is where the name 'Karma' comes from. The philosophy of Karma, in short, is: do good things, and good things will happen to you. The Karma system visualizes this process and simultaneously incentivizes users to do good for others. The philosophy of Karma, in short, is: do good things, and good things will happen to you. The Karma system visualizes this process and simultaneously incentivizes users to do good for others. Since Karma is not tied to the monetary system, it’s entirely up to us how much Karma we reward for a favor. As a general guideline, we might say that one hour of work is worth 100 Karma. However, if someone does us a big favor, we could give them 200 Karma for just 10 minutes of work, or if we feel it was a small favor, we could give only 50 Karma for an hour of work. It’s completely up to us how we value a fellow person’s favor. The basic requirement for the system to function is that each person can only have one profile, thus preventing Sybil attacks . If this condition is not met, anyone could create a new profile if their incoming and outgoing Karma balance is off, or use fake profiles to send Karma to themselves, misleading others. The perfect solution to this problem is WorldID , which provides a unique identifier linked to an iris, ensuring that each person can only have one WorldID. I’ve written a detailed article on how WorldID works. Sybil attacks WorldID https://hackernoon.com/a-brief-introduction-of-worldcoin-proof-of-unique-humanness-on-blockchain?embedable=true https://hackernoon.com/a-brief-introduction-of-worldcoin-proof-of-unique-humanness-on-blockchain?embedable=true Alongside WorldID, other elements of the World ecosystem provide an ideal foundation for Karma. WorldChain, World’s own Optimism-based L2 solution, is a perfect choice for running the system. On this chain, people with validated WorldIDs can execute transactions for free. The World App includes a built-in wallet necessary for ERC20 transactions, and the visual UI can be made accessible through a Mini App. So, is Karma money or not? One of the great lessons of the Bitcoin revolution, for me, is that money is whatever we consider it to be. If a group accepts something as money, then it is money. Money is nothing more than a social contract. In this sense, Karma can also function as money. Let’s look at an example of how Karma could replace money. If we want to get somewhere by car, we could call an Uber and pay the driver. However, we could also find someone who’s heading in the same direction and ask them to give us a ride in exchange for Karma. A whole 'favor-based Uber' service could be built on this idea. Similarly, a 'favor-based Airbnb' and other services are also conceivable. In small local communities, Karma could even fully replace money. Since all Karma transactions are permanently and publicly visible on each person’s profile, and everyone can only have one profile, Karma accounting becomes a very serious matter. We can think of it as a kind of credit system where the collateral is our unique profile and reputation. In some cases, this could even be a more substantial guarantee than a person’s wealth. Summary Although Karma can be derived from the monetary system, the goal has always been to create something better. Something that can’t be speculated on, accumulated, or increase social inequality. That’s what Karma is— a system that gamifies helping others and encourages people to do good for one another. If the concept proves even slightly workable and fulfills its promise, then it has been worth pursuing. Through Karma, perhaps the world can become a slightly better place...

Stories, News & Mentions about KWIT

Kwit’s Stories on HackerNoon

Kwit's News & Mentions