1. Using Custom Visuals from AppSource

1. Go to the Visualizations pane in Power BI Desktop.
2. Click on the three dots (…) and select “Get more visuals.”
3. Browse or search for the visual you need.
4. Add the visual to your report and configure it as required.

2. Creating Custom Visuals with R or Python

1. Enable R or Python scripting:
   • Go to File > Options and settings > Options > R scripting or Python scripting.
   • Set up the R or Python environment if you haven’t already.
2. Add a visual:
   • Click on R or Python visual from the Visualizations pane.
   • Write your R or Python script in the script editor. The script should generate a plot using libraries such as ggplot2 for R or matplotlib for Python.
3. Load data into the visual using the data fields, and Power BI will execute the script to render the visual.

3. Building Custom Visuals with Power BI Developer Tools

1. Set up the development environment:
   • Install Node.js and npm.
   • Install the Power BI Visuals Tools: npm install -g powerbi-visuals-tools.
2. Create a new visual project:
   • Use the command: pbiviz new to create a new custom visual project.
   • Navigate to the project directory: cd .
3. Develop the visual:
   • Modify the source code in the /src directory. You can use D3.js or any other JavaScript library to create your visual.
4. Test the visual:
   • Use pbiviz start to run a local server that allows you to test your visual in Power BI.
5. Package and deploy the visual:
   • Use pbiviz package to create a .pbiviz file.
   • Import this file into Power BI by selecting Import from file under the Visualizations pane.

4. Using Power BI Themes and Custom Formatting

1. Create a JSON theme file with custom color palettes and formatting options.
2. Import the theme into Power BI:
   • Go to Home > Switch Theme > Import Theme.
   • Select your JSON file to apply the custom theme to your report.

Best Practices for Creating Custom Visuals

• Plan your visualization: Understand the data and the story you want to tell. Sketch out your visual before starting the development.
• Use existing libraries: Leverage libraries like D3.js for JavaScript or ggplot2 for R to simplify development.
• Optimize performance: Ensure that your custom visuals are optimized for performance, especially when dealing with large datasets.
• Test thoroughly: Test your visuals in different scenarios and with various data to ensure they work as expected.
• Follow guidelines: Adhere to Power BI’s best practices and guidelines for custom visuals to ensure compatibility and usability

Key Symbols in Flowcharts

1. Oval (Start/End):
   • Indicates the beginning and end points of a process.
   • Example: Start, End.
2. Rectangle (Process):
   • Represents a step in the process, usually an action or operation.
   • Example: Calculate total, Update record.
3. Parallelogram (Input/Output):
   • Denotes input to the system or output from the system.
   • Example: Enter data, Display results.
4. Diamond (Decision):
   • Shows a decision point in the process, with branches for different outcomes.
   • Example: Is the number > 10? Yes/No.
5. Arrow (Flow Line):
   • Indicates the direction of flow from one step to the next.
   • Example: Moves from "Start" to "Input Data".
6. Circle (Connector):
   • Used to connect parts of the flowchart that are not directly connected.
   • Example: Connects to another part of the diagram labeled "A".

Example of a Simple Flowchart

1. Start
2. Input Number (Parallelogram)
3. Is Number % 2 == 0? (Diamond)
   • Yes: Output "Even" (Parallelogram)
   • No: Output "Odd" (Parallelogram)
4. End

Steps to Create a Flowchart

1. Identify the Process: Define the process you want to represent.
2. Determine the Steps: Break down the process into individual steps.
3. Select the Symbols: Choose appropriate symbols for each step.
4. Arrange the Steps: Organize the steps in logical order.
5. Draw the Flow Lines: Connect the symbols with arrows to show the flow.
6. Review and Refine: Check for accuracy and completeness.

Applications of Flowcharts

• Algorithm Development: Visualize algorithms to improve understanding and debugging.
• System Design: Represent systems or subsystems to communicate design and functionality.
• Process Documentation: Document business processes for analysis and optimization.
• Education and Training: Explain complex concepts in a simplified manner.

Advantages of Flowcharts

• Clarity: Provide a clear and easy-to-understand visualization of a process.
• Communication: Facilitate communication between stakeholders, including developers, managers, and non-technical team members.
• Problem Solving: Help identify bottlenecks, redundancies, and inefficiencies in processes.
• Documentation: Serve as useful documentation for maintenance and future development.

Step 1: Design Specification

• Functional Specification: Clearly outline the intended functionality, including input-output behavior, performance metrics, and power consumption targets.
• Block Diagram: Develop a high-level block diagram to visualize the main components and their interactions.

Step 2: Hardware Description Language (HDL) Coding

• Writing Code: Write HDL code for each component of the design, including logic gates, data paths, control units, and interconnections.
• Module Definition: Break down the design into smaller, manageable modules, each with its own HDL description.

Step 3: Simulation and Verification

• Testbenches: Create testbenches to simulate the HDL code, providing stimulus to the design and checking outputs against expected results.
• Functional Simulation: Use simulation tools like ModelSim or Vivado Simulator to verify the logical correctness of the design.
• Debugging: Identify and resolve bugs in the HDL code based on simulation results.

Step 4: Synthesis

• Synthesis Tools: Use synthesis tools such as Xilinx Vivado or Intel Quartus to translate HDL into a netlist, which represents the design using logic gates and flip-flops.
• Optimization: Optimize the netlist for performance, area, and power consumption.

Step 5: Implementation

• Place and Route: Place the synthesized design onto the FPGA's logic blocks and route the interconnections. This step is managed by implementation tools within the FPGA software suite.
• Constraints: Apply timing and placement constraints to guide the place-and-route process, ensuring that the design meets performance requirements.

Step 6: Bitstream Generation

• Bitstream File: Create a bitstream file, which contains the binary data needed to configure the FPGA’s logic blocks and interconnects.
• Programming File: Use the bitstream file to program the FPGA hardware.

Step 7: FPGA Programming and Testing

• Programming the FPGA: Use an FPGA programmer or JTAG interface to upload the bitstream file to the FPGA.
• Hardware Verification: Connect the FPGA to a test setup and verify its operation against the design specifications. Perform functional tests, timing analysis, and performance measurements.
• Iterative Debugging: If issues are identified, iterate through the simulation, synthesis, and implementation steps to resolve them.

Step 8: Optimization and Refinement

• Performance Tuning: Modify the design or constraints to achieve the desired performance metrics.
• Power Optimization: Adjust the design to minimize power usage, potentially involving redesigning parts of the circuit or tweaking synthesis settings.
• Resource Utilization: Ensure efficient use of the FPGA’s resources to fit within the available logic blocks and other components.

Tools and Software

• HDL Editors: Integrated Development Environments (IDEs) like Xilinx Vivado, Intel Quartus, or others that support HDL coding.
• Simulation Tools: ModelSim, Vivado Simulator, or similar tools for functional verification.
• Synthesis Tools: Included in Vivado, Quartus, or other FPGA toolchains.
• Place and Route Tools: Part of the FPGA design suite, handling placement and routing.
• FPGA Programmer: Hardware tools such as USB blasters or JTAG interfaces for programming the FPGA.

Conclusion

 reg [15:0] y, y_init, u; reg [15:0] x_curr, x_curr0, x_curr1, x_curr2, x_next, x_next2, x_next3; reg [15:0] e_pre_var, e_next_var, e_next_var1, e_next_var2; reg [15:0] K_pre, K_next, one_K_next_sq, K_next_sq; // kalman gain always@(posedge clk) begin // distribute calculations over multiple clock cycles to meet timing // all variables that are not declared as reg are parameters if (counter == 9) begin y_init = y_measured; end if (counter == 10) begin x_next2 = k_omega*y_init; x_next3 = oT*x_next2; measured = x_next3; end if (counter == 11) begin x_next = x_next1 - x_next3; // predict the next state x_n e_pre_var = e_pre_var0; end // counter1024 counts up to 1024 clock cycles, so the following makes calculations every 1024 //cycles // this reduces the calculation rate from 125 MHz if (counter_eq_1024) begin y = y_measured; u = -oT*k_omega*y; end if (counter1024 == 1) begin K_next_num = (phi_sq*e_pre_var + d_var); K_next_denom = (phi_sq*e_pre_var + d_var + s_var); // K_next = K_next_num / K_next_denom; M_AXIS_OUT_tvalid_kal = 1'b1; // send the numerator and denominator values to the Divider Generator K_next = K_next_in; end if (counter1024 == 2) begin x_curr0 = 1-K_next; x_curr1 = x_curr0*x_next; x_curr2 = K_next*y; end if (counter1024 == 3) begin x_curr = x_curr1 + x_curr2; // estimate the current state x_next = phi*x_curr + u; // predict the next state end if (counter1024 == 4) begin one_K_next_sq = (1-K_next)*(1-K_next); K_next_sq = K_next*K_next; end if(counter1024 == 5) begin e_next_var1 = one_K_next_sq*K_next_num; e_next_var2 = K_next_sq*s_var; e_next_var = e_next_var1 + e_next_var2; end if (counter1024 == 6) begin // make the next values the old values for next cycle K_pre = K_next; e_pre_var = e_next_var; // Assign the calculated value to the output signal M_AXIS_OUT_tdata = x_next; // Store sampled data in memory x_data = x_next; M_AXIS_OUT_tvalid_kal = 1'b0; // stop data flow to Divider Generator end end 

1. while my wifi is strong in the garage, I was never able to connect until I inserted the following lines in my configuration:

 on_boot: priority: 300 then: lambda: - WiFi.setPhyMode(WIFI_PHY_MODE_11G); 

1. I setup a DNS lease for the device, yet I chose eventually to manually assign the IP address in the config as well to prevent eventual DHCP timeouts.
   

    manual_ip: # Set this to 34 for Door 2 or 33 for Door 1 static_ip: gateway: subnet: 10.0.0.3310.0.0.1255.255.255.0 

2. I followed Paul's sequence with no success:
   

• Make sure you have already installed and configured the ratgdo firmware.
• Unplug the door opener
• Connect the wires according to the diagram below
• Plug the door opener back in
• Power ratgdo with the USB power brick & cable.

• Unplug the Opener
• Reflash the Board
• Reconfigure the board
• Connect to opener wiring if not already
• Power the Ratgdo
• Power the Garage door
• Cycle the door using the physical wall button
• Wait a moment or seven while the ratgdo syncs

1. If the opener has a battery backup, is it sufficient to unplug and replug the opener? Shall I also remove the battery?
2. How long does the opener learning sequence last? At which point should I unplug the opener again?
3. My understanding is that learning a wall-mounted button (and the RATGDO) is different than learning a remote. The Learn button is for the remotes only and is not needed by the RATGDO. Am I correct?
4. Should I ever use the Sync button found on the RATGDO webpage? When am I supposed to activate it? At the onset or whenever I lose a prior synchronization? The web UI documentation states: "Manually sync the ratgdo client with the GDO. If the GDO isn't responding to commands from ratgdo, a sync should force them to be on the same rolling code counter."
5. At which point, shall I call the board defective?

1. Energy Utilization: Cognitive systems and social networks require energy to function and maintain order.
2. Entropy Reduction: Intelligent behavior and cohesive social dynamics are associated with reducing internal entropy, increasing complexity and organization.

1. Information Flow: Cognitive systems and social networks process and transmit information, which is subject to noise and distortion.
2. Entropy and Information: The entropy of a system can be related to the amount of uncertainty or information within that system.
3. Information Density: The concentration of useful information within a given volume of data, influencing the efficiency of cognitive and social processes.

1. Flow and Pressure: Just as fluids flow through pipes, information and energy flow through cognitive systems and social networks, driven by gradients in pressure and potential.
2. Cavitation and Pressure Dynamics: Sudden changes in pressure, analogous to cavitation in fluids, can represent abrupt shifts in cognitive states or social dynamics.

1. Perception and Action: Cognitive systems perceive their environment and take actions to achieve specific goals. Social networks exhibit collective behavior and decision-making.
2. Prediction and Learning: Systems learn from past experiences to improve future predictions and actions. Social networks evolve based on shared information and collective experiences.
3. Flocking Behavior: Social networks exhibit flocking behavior, where groups align their actions and decisions, creating probability clusters and influencing group dynamics.
4. Neural Network Analogy: Each social network can be considered a neural network, where group decision-making and entropy reduction parallel cognitive processes.

1. Continuous Time: Time is represented as a continuous flow, with cognitive and social states evolving smoothly over time.
2. Temporal Prediction: Cognitive systems and social networks generate predictions about future states based on past and present information.

1. Energy Flow: Cognitive systems and social networks consume and allocate energy to maintain order and perform tasks.
2. Entropy Management: Systems actively manage entropy to reduce uncertainty and increase efficiency.

1. Information Flow: Cognitive systems and social networks process information continuously, adjusting their internal states based on new data.
2. Error Correction: Systems use feedback mechanisms to correct errors and improve future predictions.

1. Information Density: High-density information systems and social networks concentrate more useful data within a given volume, leading to more efficient processing.
2. Quality of Information: High-quality information reduces contradictions and improves system performance. Contradictions cause token and rule bloat, leading to inefficiencies.

1. Contradictions and Bloat: Low-density systems often store redundant or contradictory information, leading to token and rule bloat.
2. Energy Waste: Such systems require more energy to process and resolve contradictions, resulting in lower efficiency.
3. Poor Performance: The increased computational load reduces the system's overall performance and responsiveness.

1. Optimized Information Storage: High-density systems store information in a more compact and optimized manner, reducing redundancies.
2. Enhanced Efficiency: By minimizing contradictions and bloat, these systems achieve higher efficiency and faster processing speeds.
3. Smaller Hardware Requirements: High-density information systems can perform well even in smaller hardware environments, making them suitable for resource-constrained applications.

1. Value Inference and Prediction: In high-density systems, values inferred from actions are used to predict future actions. ROBDDs provide an efficient method for representing and manipulating Boolean functions, aiding in value inference and decision-making.
2. Comparative Analysis: High-density systems using ROBDDs can be compared to low-density systems to predict and quantify information waste and inefficiencies.

1. Group Dynamics: Social networks exhibit flocking behavior, where individuals align their actions and decisions based on shared information and group influence.
2. Probability Clusters: Flocking behavior leads to the formation of probability clusters, where certain outcomes or behaviors become more likely due to group dynamics.

1. Analogous Processes: Social networks can be modeled as neural networks, with nodes representing individuals and connections representing social interactions and information flow.
2. Group Decision-Making: Collective decision-making processes in social networks parallel neural network processing, where the network evolves based on shared information and collective experiences.
3. Entropy Management: Social networks, like cognitive systems, actively manage entropy to reduce uncertainty and increase efficiency.

1. Member Lifespan: The membership of a social network is dynamic, with individuals joining and leaving over time. This can be modeled as a time-dependent variable affecting the structure and function of the network.
2. Venn Diagram Representation: Each slice of the "Pipe of Time" can be represented as a Venn diagram, illustrating the overlapping memberships and the temporal dynamics of group composition.

1. Membership Evolution: The membership of a social network evolves over time, affecting the overall structure and function of the network. This can be represented by a time-dependent membership function ( M(t) ), which influences the state vector ( \mathbf{X}(t) ).
2. Venn Diagram Dynamics: The dynamic membership can be visualized using Venn diagrams, where each slice of the "Pipe of Time" represents a different temporal state of the network, showing the overlap and interactions of different subgroups.

1. Why?
2. my immediate thought here is either that he wants to hide why he named Titania after the character in Midsummer, or one of the other Lyctors’ redacted names is too important in a play and he just had to scrap the whole thing (so C— is actually Cordelia or P— is Portia, etc)
   
3. Who told Dulcie?
   
4. we know she’s on the other side of the river, which we know Very little about. For her to still be learning after death, I think there have to be others over there with her, right? Either it’s Heaven and she met the real Billy Shakes, or like, idk, it’s the Lyctors who got eaten by the Resurrection Beasts and that’s how you cross over. I’m low on ideas here but it feels important— if anyone has any guesses I’d love to hear them!
   

What's it

How it works

• Zero repo-specific configuration: It can be applied to most languages and repositories without additional configuration.
• Low extension cost: adding rules for languages is not high.
• Acceptable precision: We have sacrificed a certain level of precision, but we also hope that it remains at an acceptable level.

1. Extract imports and exports: Identify the imports and exports of each file.
2. Connect nodes: Establish connections between potential definition and reference nodes.
3. Refine edges with commit histories: Utilize commit histories to refine the relationships between nodes.

1. Minimal impact on accuracy: In practical scenarios, the loss of precision is not as significant as one might expect.
2. Commit history relevance: The use of commit history to reflect the influence between code segments aligns well with our objectives.
3. Language support: We can easily support the vast majority of programming languages, meeting the analysis needs of various types of repositories.

Usage

# diff between HEAD and HEAD~1 gossiphs diff # custom diff gossiphs diff --target HEAD~5 gossiphs diff --target d18a5db39752d244664a23f74e174448b66b5b7e # output json gossiphs diff --json 

• ADDED: Refers to file relationships added in this diff
• DELETED: Refers to file relationships deleted in this diff
• Others: Refers to file relationships that were not affected by this diff and originally existed

Repo

• Node.js: Main server-side framework.
• MongoDB: Database, using AWS DocumentDB with MongoDB compatibility.
• Redis: Caching mechanism.
• AWS Batch: For managing batch processing jobs.
• AWS ECR: Container storage.
• External APIs: For malware watch.

1. User Requests: Begin with a user request
2. Node.js Server: Receives and processes the request, interacting with other components.
3. DocumentDB (MongoDB Compatibility): Queries or updates data as needed.
4. Redis Cache: Improves performance by caching frequent queries.
5. AWS Batch Processing:
   • Job Submission: Jobs are submitted to AWS Batch for intensive processing.
   • Job Processing: Managed by AWS Batch, running custom scripts.
   • Docker Containers: Jobs are executed within Docker containers, stored in AWS ECR.
6. ECR Registry: Stores Docker images for batch processing.
7. Batch Coordination:
   • Batch Completion: System waits until all jobs are completed.
   • Results Aggregation: Aggregated results are sent to the frontend.

1. User makes a request → 2. Node.js server processes request → 3. Queries/updates in DocumentDB → 4. Checks Redis cache → 5. Submits jobs to AWS Batch → 6. Jobs executed in Docker containers → 7. Containers stored in ECR → 8. All jobs complete and results aggregated → 9. Results sent to frontend.

• How APIs interact with each other.
• The flow of data from the user request to the final result.
• How to represent batch processing and Docker container interactions.
• The role of each component in the overall architecture.
• GitHub workflows

1. Using connecting cables, connect computers and network devices according to the diagram shown in the figure on the previous page.
   
2. Configure the router's network interfaces as recommended. If the router setup process forces you to change your passwords, record your login information after the change:
   

1. Configure the switch connected to the router as recommended. If the switch configuration process forces you to change your password, report the login information after the change:

1. On the workstation connected to port 3 of the switch connected to the router, configure the wired NIC as follows:

1. On the printer or IoT device, configure the wired NIC network interface as recommended:

1. Check whether there is a connection from the workstation command line to the router and printer (IoT device).
   
2. Save the report document on the medium described as EFFECTS and hand it over to the teacher for evaluation.